Compare commits

..
Author SHA256 Message Date
tram 97f90167f1 Добавить поддержку уведомлений 2026-08-21 13:23:41 +03:00
897 changed files with 33492 additions and 114095 deletions
-23
View File
@@ -78,8 +78,6 @@ shine-solana/shine/scripts/**/TEMP_*.md
# Локальные артефакты и внешние материалы ESP32-подпроекта
ESP32/esp32-config-tool/
ESP32/local-sketches/
ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/main-device/test_sketches/breath_dual_mode_monitor/
ESP32/**/.git/
ESP32/**/.idea/
ESP32-wallet/.idea/
@@ -107,7 +105,6 @@ ESP32/**/*.a
# Полные серверные бэкапы (тяжёлые архивы, не коммитим)
deploy/backup/archive/**
!deploy/backup/archive/.gitkeep
SHiNE-bundle-*.zip
# Локальная дев-обвязка AI-агентов (сессии, планы, настройки) — не коммитим
.agents/
@@ -116,23 +113,3 @@ SHiNE-bundle-*.zip
# Рабочие бэкапы/превью-ассеты UI — не для репозитория
*.bak.png
shine-UI/assets/navbar_preview.png
# Private local configuration: keep on disk, never push to GitHub
/SHiNE-server/src/main/resources/application.properties
/application.properties
/deploy/backup/scheme/
/shine-solana/shine/create-SHiNE-DAO/dao.config.mainnet.env
**/.env
**/.env.*
!**/.env.example
!**/.env.sample
# Private key files and local credential stores (never commit)
*.key
*.pem
*.p12
*.pfx
*.jwk
*.jks
*.keystore
*keypair*.json
+141 -21
View File
@@ -1,27 +1,147 @@
# Инструкции для агентов SHiNE
# AGENTS
Этот файл относится к репозиторию SHiNE. По умолчанию писать документацию, пользовательские пояснения и сообщения коммитов на русском языке.
## Язык проекта
- По умолчанию использовать русский язык во всех пользовательских текстах и технических пояснениях.
- Пояснения к коммитам, PR и merge-запросам писать на русском языке.
- Комментарии в коде, встроенные справки, документацию и инструкции писать по возможности на русском языке.
## Сначала определить область работы
## Примечание
- Если внешний инструмент/интеграция требует английский формат, допускается английский, но рядом желательно дать краткое пояснение на русском.
| Область | Код | Правила и документация |
| --- | --- | --- |
| Сервер, WebSocket/API, PostgreSQL | `SHiNE-server/` | `SHiNE-server/AGENTS.md`, `docs/API/` |
| Блокчейн, Arweave | `SHiNE-server/shine-server-blockchain/` | `docs/Blockchain/README.md` |
| Личные сообщения | сервер и `shine-UI/` | `docs/Personal_Messages/README.md`, локальный `AGENTS.md` |
| Браузерный UI | `shine-UI/` | `shine-UI/AGENTS.md`, `docs/UI-Design/README.md` |
| Solana/Anchor | `shine-solana/shine/` | локальный `AGENTS.md`, `docs/Solana_Architecture/README.md` |
| ESP32 | `ESP32/` | `ESP32/AGENTS.md`, инструкции конкретного устройства |
| Деплой и резервные копии | `deploy/` | `deploy/AGENTS.md`, `deploy/backup/AGENTS.md` |
| Тестовый издатель | `tools/test-publisher/` | локальный `AGENTS.md` |
## Структура проекта (кратко)
- Серверный код SHiNE находится в папке `SHiNE-server/`.
- Код клиентского UI SHiNE находится в папке `shine-UI/`.
- Веб-панель администратора сервера (управление Solana PDA сервера) находится в `shine-UI/`:
- точка входа `shine-UI/server-ui.html`;
- остальные файлы серверного UI — в `shine-UI/server-ui/`.
- Локальный Telegram-бот агента-кодера живёт рядом с репозиторием продукта, обычно в `../SHiNE-agent-bot-coder/`, и не входит в публичный код основного приложения.
- Solana/Anchor-модуль находится в папке `shine-solana/shine/` и ведётся отдельно от основного server/UI деплоя.
Общий каталог — `docs/README.md`; карта компонентов и потоков данных — `docs/ARCHITECTURE.md`. Правила сопровождения документов — `docs/CONTRIBUTING_DOCS.md`; после правки документации запускать `python3 scripts/check_docs.py`. Планы в `TODO/` не считать описанием действующего поведения или разрешением на реализацию.
## Сервис агента-кодера
- Локальный Telegram-бот-сервис агента-кодера находится вне этого git-репозитория, обычно в `../SHiNE-agent-bot-coder/`.
- Сервис принимает сообщения из Telegram, ведёт историю диалога, ставит задачи в очередь и вызывает Codex CLI для обработки запросов по проекту.
- Рабочая папка Codex для сервиса должна указывать на этот продуктовый репозиторий: `CODEX_WORKDIR=/home/ai/work/SHiNE/SHiNE-server-sha256/SHiNE-product`.
- Автоматически читаемые инструкции для Codex внутри сервиса держать в `../SHiNE-agent-bot-coder/AGENTS.md`.
- Подробные служебные правила Telegram-обработчика, его очередь, история, systemd-запуск и особенности ответов описывать в `../SHiNE-agent-bot-coder/AGENT.md`.
- Если в сообщениях пользователя встречается «агент MD» или похожая формулировка про файл инструкций Codex, считать, что имеется в виду автоматически читаемый `AGENTS.md`.
## Постоянные правила
## ESP32 UI homeserver
- Для UI-скетча устройства `ESP32-S3-Touch-AMOLED-2.16` документ-спецификация и Arduino-скетч должны всегда оставаться синхронными.
- Актуальный документ по экранной логике, состояниям, кнопкам, полям, статусам и ограничениям UI считать источником истины для скетча.
- При изменении документа обязательно в том же наборе изменений приводить в соответствие скетч.
- При изменении скетча обязательно в том же наборе изменений обновлять документ, если поменялись экраны, тексты, переходы, статусы, кнопки, поля или поведение.
- Для нового ESP32 UI-прототипа homeserver использовать русский язык как основной и отдельно следить, чтобы текст реально отображался на устройстве, а не только логически присутствовал в коде.
- Прежде чем править подсистему, прочитать её локальный `AGENTS.md` и действующую документацию через `docs/README.md`. Архивные отчёты и старые планы не использовать как текущий контракт. При расхождении документа с кодом проверить реализацию и исправить документ либо явно отметить неопределённость.
- Изменение поведения, формата, API, конфигурации или пользовательского сценария сопровождать обновлением соответствующего документа в том же наборе изменений. Не выдавать план, черновик или тестовое состояние за действующую функцию.
- Формат блокчейна и контракт серверного API изменять только после отдельного явного согласия пользователя; документировать изменения в `docs/Blockchain/` и `docs/API/`. Для добавления блока использовать `AddBlock` с актуальной вершиной цепочки.
- Любые изменения и деплой production (`shineup.me`, `server2.shineup.me`) — только после отдельного явного согласия пользователя. Перед деплоем прочитать `deploy/AGENTS.md` и проверить резервную копию. Для деплоя использовать скрипты `deploy/scripts/`.
- Секреты, приватные ключи, локальные конфиги, сборочные артефакты и логи не добавлять в git.
- Коммиты, версии и merge выполнять по `COMMIT_AND_VERSION_RULES.md`. Не делать коммит или push без необходимости для задачи.
## Solana-модуль
- В проекте есть отдельный Solana/Anchor-модуль в папке `shine-solana/shine/`.
- Модуль логически связан с SHiNE, но не должен автоматически подключаться к сборке или деплою основного сервера без отдельного решения.
- В Solana-модуле действуют локальные инструкции `shine-solana/shine/AGENTS.md`; при изменениях внутри модуля сначала читать их.
- В git добавлять исходники, lock-файлы, настройки проекта и документацию Solana-модуля, но не добавлять локальные ключи, `.git`, `.idea`, `.gradle`, `target`, `node_modules`, `test-ledger`, логи, временные run-отчёты и `.env`-конфиги.
- Для Solana deploy/push использовать правила из локального `shine-solana/shine/AGENTS.md`; не смешивать deploy Solana-модуля со скриптами основного server/UI deploy из `deploy/scripts/`.
- Для регистрации пользователей в Solana (программа `shine_users`) единая актуальная инструкция по деплою/инициализации, адресам программ, и куда их прописывать в UI/сервере находится в:
- `docs/Инициализация_Solana_регистрации/README.md`
- Этот файл считать основной справкой (single source of truth) по деплою и первичной инициализации Solana-регистрации в текущем проекте.
- Актуальная архитектурная справка по устройству Solana-программ, PDA-счетам, ролям DAO и движению средств находится в:
- `docs/Solana_Architecture/README.md`
- Документ формата пользовательской PDA-записи `shine_users` находится в:
- `shine-solana/shine/doc/formats/shine-user-pda-format-v.1.0.md`
- Актуальная документация по серверному модулю синхронизации Solana users находится в:
- `docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md`
- При любом изменении логики серверной синхронизации `shine_users`, её таблиц PostgreSQL, checkpoint-механизма, startup/lifecycle или deploy-настроек обязательно обновлять:
- `docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md`
- `deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md`
## Документация блокчейна
- Актуальная документация по форматам блокчейна находится в `docs/Blockchain/README.md`.
- Это точка входа (оглавление), рядом расположены детальные файлы по форматам, типам каналов и командным сообщениям.
- При любом изменении кода, связанного с блокчейном (формат блока, типы каналов, правила чтения/записи, команды), обязательно обновлять соответствующие документы в `docs/Blockchain/`.
- Дополнительно обязательно вести `docs/Blockchain/CHANGELOG.md`: дописывать изменения построчно с указанием даты/времени и хэша коммита, после которого внесено изменение.
- Перед любым изменением формата блокчейна обязательно заранее предупреждать пользователя, что формат будет изменён.
- Изменять формат блокчейна можно только после явного подтверждения пользователя (без подтверждения формат не менять).
- Добавление любых данных в блокчейн выполнять только через операцию `AddBlock`.
- Перед каждым `AddBlock` обязательно проверять/актуализировать текущее состояние вершины блокчейна (`last global number/hash`) и использовать его при формировании блока.
## Документация личных сообщений (DM)
- Актуальная документация по логике личных сообщений находится в `docs/Personal_Messages/Протокол_DM_v1.md`.
- Точный байтовый формат DM находится в `docs/Personal_Messages/Формат_DM_v1.md`.
- При любом изменении кода, связанного с личными сообщениями (формат подписанного DM-блока, типы DM-сообщений, правила доставки/ACK/read-receipt, роутинг по сессиям, UI-логика чатов), обязательно обновлять оба документа:
- `docs/Personal_Messages/Протокол_DM_v1.md`
- `docs/Personal_Messages/Формат_DM_v1.md`
- Логика личных сообщений в коде должна всегда соответствовать этим документам.
- Документ по личным сообщениям обязан поддерживаться в актуальном состоянии.
## Документация API сервера
- Актуальная документация по публичному JSON/WebSocket API сервера находится в `docs/API/`.
- При любом изменении серверного API/эндпоинтов/операций `op` обязательно обновлять соответствующие документы в `docs/API/`.
- Перед изменением самого серверного API обязательно явно предупредить пользователя, какие операции, поля запросов/ответов или коды ошибок будут изменены, и запросить отдельное подтверждение.
- Без явного подтверждения пользователя формат серверного API не менять; допускается только приведение документации в соответствие уже существующему коду.
- Если добавляется новая операция `op`, нужно обновить общий список операций в `docs/API/09_Operations_Index.md` или создать его, если файла ещё нет.
## Документация Figma
- Актуальная документация по переносу экранов SHiNE в Figma и обратному переносу из Figma в код находится в `docs/Figma/`.
- Точка входа: `docs/Figma/README.md`.
- Подробный рабочий регламент: `docs/Figma/TRANSFER_UI_SCREENS.md`.
- Для экранов регистрации, входа и других чувствительных UI-flow по умолчанию переносить экраны в Figma по одному, а не пачкой, если пользователь отдельно не подтвердил иной способ.
## Версионирование
- Все правила по коммитам, merge в `main`, `git push` и обновлению `VERSION.properties` находятся в `COMMIT_AND_VERSION_RULES.md`.
- Этот файл считать единым источником истины по правилам версионирования и коммитов для данного репозитория.
## Deploy
- Все документы, инструкции, backup-правила и скрипты деплоя хранить в папке `deploy/`.
- Подробные правила для агента по деплою находятся в `deploy/AGENTS.md`; перед любым deploy читать этот файл.
- Production-серверы SHiNE: `shineup.me` и `server2.shineup.me`.
- Тестовые/devnet серверы SHiNE: `t1.shineup.me`, `t2.shineup.me`, `t3.shineup.me`, `t4.shineup.me`.
- В deploy-документах и скриптах использовать домены, а не IP.
- По возможности все справки, комментарии и примечания в конфигах/документах писать на русском языке.
- Любые изменения и любой деплой на production (`shineup.me` и `server2.shineup.me`) выполнять только после отдельного явного подтверждения пользователя.
- Перед production deploy обязательно проверить/обновить бэкап в `deploy/backup/archive/`.
- Если пользователь пишет просто `задеплой` без уточнения production/test, уточнить целевой контур; не выбирать production автоматически.
- Deploy выполнять shell-скриптами из `deploy/scripts/`; Gradle deploy-задачи не использовать.
- Для локального запуска использовать `./gradlew startLocal` (или `startLocalWithBuild`).
- Сначала предлагать локальную проверку, а деплой на сервер выполнять по запросу пользователя.
- Для временной бесплатной загрузки аватаров в Arweave секретный JWK нельзя хранить в git и нельзя прописывать в репозиторный `application.properties`.
- Для продовой настройки тестового Arweave-кошелька JWK-файл нужно хранить только на сервере, например: `/home/player/SHiNE/secrets/test-free-avatar-wallet.json`.
- Для этой временной фичи на проде должны быть заданы параметры `test.freeAvatar.walletJwkPath` и `test.freeAvatar.walletAddress` через серверный override-конфиг/секреты на хосте.
- После изменения продовых значений `test.freeAvatar.*` нужно заново выполнить серверный деплой или перезапуск сервера, чтобы настройки были перечитаны приложением.
- При таких изменениях в git допускается коммитить только документацию и код чтения настроек, но не сам JWK, не содержимое секрета и не реальные приватные ключи.
## Логи звонков (установка соединения)
- Специальный поток диагностики установки звонков идёт через `CallDeliveryReport` (клиент → сервер).
- На проде специальный файл для звонков:
- `/home/player/SHiNE/shine-server/logs/call-delivery-events.log`
- Общий серверный лог (и ротации) на проде:
- `/home/player/SHiNE/shine-server/logs/app.log`
- `/home/player/SHiNE/shine-server/logs/app.YYYY-MM-DD.log`
- Для анализа причин недозвона в первую очередь фильтровать записи по ключам:
- `CallDeliveryReport`
- `call_connected`
- `outgoing_failed`
- `incoming_failed`
- `call_busy`
- `call_declined`
- `unknown_error`
- В этих записях искать поля `reason`, `failureStage`, `pcConnectionState`, `pcIceConnectionState`, `routeLabel`, `configuredTurnHosts*`, `reachableTurnHosts*`.
## Будущие фичи / TODO
- Папка для задач, сознательно отложенных на будущее: `TODO/`.
- Точка входа по планам: `TODO/README.md`.
- Внутри планы разделены по горизонтам: `near/`, `medium/`, `far/` и тематическим подпапкам.
- Если пользователь спрашивает, какие есть планы или что можно продолжить, сначала читать `TODO/README.md`, затем при необходимости конкретные файлы из подпапок.
- Файлы из этой папки не считать активными задачами и не начинать реализацию без явной просьбы пользователя.
- Старую папку `docs/Future_Features/` считать выведенной из использования и больше не использовать для новых записей.
- Если часть кода временно отключена или закомментирована, либо удалена как временная заглушка, в TODO-файле подробно описывать:
- какие файлы и участки отключены;
- что осталось в коде как заготовка;
- какие документы нужно обновить при возврате;
- с какого сценария продолжать разработку;
- из какого коммита брать последнюю полную реализацию.
## Коммуникация по новым задачам (обязательно)
- При получении нового задания сначала кратко пересказать задачу своими словами.
- До начала реализации задать недостающие уточняющие вопросы (если они есть).
- Если есть уместные идеи/улучшения — кратко предложить их; если полезных идей нет, ничего дополнительно не предлагать.
- Добавлять краткую оценку фичи (насколько это полезно/удачно по мнению исполнителя).
- После этого обязательно запросить подтверждение от пользователя, что задача понята верно, и только после подтверждения переходить к реализации.
- Если вопросов нет, явно написать в формате: «Я всё понял, начинаю делать?» и ждать подтверждения.
- Без подтверждения пользователя реализацию не начинать.
+9
View File
@@ -32,6 +32,15 @@
- По умолчанию в `main` нужно не коммитить напрямую, а мержить готовые изменения из рабочей ветки.
- Если пользователь просит сделать прямой коммит в `main`, нужно отдельно и явно предупредить, что это обход обычного стабильного процесса, и обязательно переспросить подтверждение.
## Версионирование при merge или прямом коммите в `main`
- Для попадания изменений в `main` действует отдельная схема инкремента.
- Нужно увеличивать вторую цифру версии и обнулять третью.
- Пример: `1.2.346` → `1.3.0`.
- Если в наборе изменений менялся только UI, обновлять только `client.version`.
- Если в наборе изменений менялся только сервер, обновлять только `server.version`.
- Если соответствующая часть не менялась, её версию не трогать.
## Правила для git commit и git push
- Обычные коммиты делать стандартным `git commit`; токен для локального коммита не нужен и не используется.
@@ -1,52 +0,0 @@
#!/usr/bin/env bash
set -euo pipefail
ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
MODE="${1:-potentiometer-adc-test}"
PORT="${PORT:-}"
case "$MODE" in
potentiometer-adc-test)
SKETCH_DIR="$ROOT_DIR/test_sketches/potentiometer_adc_test"
BUILD_DIR="$ROOT_DIR/.arduino-build/build-potentiometer-adc-test"
;;
buzzer-gpio6-test)
SKETCH_DIR="$ROOT_DIR/test_sketches/buzzer_gpio6_test"
BUILD_DIR="$ROOT_DIR/.arduino-build/build-buzzer-gpio6-test"
;;
*)
echo "Unknown mode: $MODE" >&2
echo "Known modes: potentiometer-adc-test, buzzer-gpio6-test" >&2
exit 2
;;
esac
if [[ -z "$PORT" ]]; then
PORT="$(arduino-cli board list | awk '/ttyACM|ttyUSB/ {print $1; exit}')"
fi
if [[ -z "$PORT" ]]; then
echo "No serial port found. Set PORT=/dev/ttyACM0 explicitly." >&2
exit 1
fi
FQBN="esp32:esp32:esp32s3:USBMode=hwcdc,CDCOnBoot=cdc,UploadSpeed=921600,CPUFreq=240,FlashMode=dio,FlashSize=16M,PartitionScheme=app3M_fat9M_16MB,PSRAM=opi"
echo "== Mode: $MODE"
echo "== Sketch: $SKETCH_DIR"
echo "== Port: $PORT"
echo "== FQBN: $FQBN"
arduino-cli compile \
--fqbn "$FQBN" \
--build-path "$BUILD_DIR" \
"$SKETCH_DIR"
arduino-cli upload \
--fqbn "$FQBN" \
-p "$PORT" \
--input-dir "$BUILD_DIR" \
"$SKETCH_DIR"
echo
echo "== Done."
@@ -1,3 +0,0 @@
# AGENTS
This folder contains a temporary GPIO6 buzzer diagnostic for ESP32-S3-LCD-2. Keep screen/serial strings in English.
@@ -1,51 +0,0 @@
#include <Arduino.h>
// Buzzer module wiring: GND -> GND, VCC -> 3V3, I/O -> P1 IO6 / GPIO6.
static constexpr uint8_t PIN_BUZZER = 6;
static constexpr uint32_t STEP_MS = 1800;
static uint8_t gStep = 0;
static uint32_t gChangedMs = 0;
static void applyStep(uint8_t step) {
ledcDetach(PIN_BUZZER);
pinMode(PIN_BUZZER, OUTPUT);
digitalWrite(PIN_BUZZER, LOW);
delay(80);
switch (step) {
case 0:
pinMode(PIN_BUZZER, OUTPUT);
digitalWrite(PIN_BUZZER, HIGH);
Serial.println("TEST 1: GPIO6 HIGH - active-high module should sound");
break;
case 1:
pinMode(PIN_BUZZER, OUTPUT);
digitalWrite(PIN_BUZZER, LOW);
Serial.println("TEST 2: GPIO6 LOW - active-low module should sound");
break;
case 2:
ledcAttach(PIN_BUZZER, 1800, 8);
ledcWriteTone(PIN_BUZZER, 1800);
ledcWrite(PIN_BUZZER, 180);
Serial.println("TEST 3: GPIO6 PWM 1800 Hz - passive module should sound");
break;
default:
pinMode(PIN_BUZZER, OUTPUT);
digitalWrite(PIN_BUZZER, LOW);
Serial.println("SILENCE");
break;
}
}
void setup() {
Serial.begin(115200);
Serial.println("GPIO6 BUZZER TEST: HIGH, LOW, PWM, SILENCE. Each step lasts 1.8 seconds.");
applyStep(gStep);
gChangedMs = millis();
}
void loop() {
if (millis() - gChangedMs < STEP_MS) return;
gStep = (gStep + 1) % 4;
applyStep(gStep);
gChangedMs = millis();
}
@@ -1,17 +0,0 @@
# AGENTS
## Назначение папки
Эта папка содержит отдельный тестовый Arduino-скетч `potentiometer_adc_test.ino` для Waveshare `ESP32-S3-LCD-2`.
Скетч проверяет переменный резистор на обычных GPIO/ADC, без использования USB `D+ / D-`.
## Обязательная синхронизация
При любом изменении `potentiometer_adc_test.ino` обязательно обновлять рядом лежащий `README.md`.
Если меняются экранные тексты, режимы, пины подключения, правила расчёта, touch-кнопки или serial-команды, описание в `README.md` должно быть обновлено в том же наборе изменений.
## Язык экрана
Экранные строки в скетче оставлять на английском языке.
@@ -1,73 +0,0 @@
# Potentiometer ADC Test for ESP32-S3-LCD-2
Тестовый скетч для Waveshare `ESP32-S3-LCD-2`.
Назначение: проверить переменный резистор `RP 6045-B50K` через обычные GPIO/ADC, без использования USB `D+ / D-`.
## Пины
Используются пины с разъёма `P1` платы:
- `GPIO2 / IO2` — ADC-вход, сюда подключается ползунок потенциометра.
- `GPIO6 / IO6` — DRIVE-выход для грубого 2-проводного режима.
- `3V3` — питание потенциометра для 3-проводного режима, находится на разъёме `P2`.
- `GND` — земля.
Не подавать `5V` на `GPIO2` или `GPIO6`: GPIO ESP32-S3 не являются 5V tolerant.
## Режимы
Переключение:
- touch-кнопка `3-WIRE`;
- touch-кнопка `2-WIRE`;
- серийная команда `m`;
- короткое нажатие `BOOT / GPIO0`.
Сброс min/max:
- touch-кнопка `RESET`;
- серийная команда `r`.
## 3-Wire Mode
Правильное подключение:
- один край потенциометра -> `3V3`;
- второй край потенциометра -> `GND`;
- средний ползунок -> `GPIO2 / IO2`.
Скетч показывает напряжение на ползунке, raw ADC, абсолютное положение от `0..3.3V`, калиброванное положение между найденными min/max и примерное сопротивление участка `0..50 kΩ`.
## 2-Wire Mode
Грубое подключение:
- один край потенциометра -> `GPIO6 / IO6`;
- средний ползунок -> `GPIO2 / IO2`;
- второй край не подключать.
`GPIO6` выдаёт `HIGH`, `GPIO2` читается как ADC с внутренней подтяжкой вниз. Такой режим показывает движение ползунка, но не даёт точного сопротивления: внутренняя подтяжка ESP32 имеет большой разброс.
## Экранные данные
На экране выводятся:
- режим и схема пинов;
- raw ADC и millivolts;
- абсолютный процент от `0..3300 mV`;
- калиброванный процент по найденному min/max;
- min/max/span;
- EMA-сглаживание;
- примерная оценка сопротивления;
- статус `OPEN/LOW/MID/HIGH/SATURATED/NO SPAN`;
- координаты последнего touch;
- serial-подсказка.
## Сборка
Из папки `main-device`:
```bash
./burn.sh potentiometer-adc-test
```
@@ -1,348 +0,0 @@
#include <Arduino.h>
#include <Arduino_GFX_Library.h>
#include <Wire.h>
#include <bsp_cst816.h>
#define PIN_LCD_SCLK 39
#define PIN_LCD_MOSI 38
#define PIN_LCD_MISO 40
#define PIN_LCD_DC 42
#define PIN_LCD_RST -1
#define PIN_LCD_CS 45
#define PIN_LCD_BL 1
#define PIN_TP_SDA 48
#define PIN_TP_SCL 47
#define PIN_ADC_WIPER 2
#define PIN_DRIVE_2WIRE 6
#define PIN_BOOT_BUTTON 0
static const uint16_t DISP_W = 320;
static const uint16_t DISP_H = 240;
static const uint32_t ADC_FULL_MV = 3300;
static const float POT_OHMS = 50000.0f;
static const float ROUGH_PULLDOWN_OHMS = 45000.0f;
static const uint16_t C_BG = 0x0841;
static const uint16_t C_PANEL = 0x18E3;
static const uint16_t C_CARD = 0x2126;
static const uint16_t C_TEXT = 0xF7BE;
static const uint16_t C_MUTE = 0x8C71;
static const uint16_t C_ACCENT = 0x05DF;
static const uint16_t C_OK = 0x47E8;
static const uint16_t C_WARN = 0xFD20;
static const uint16_t C_BAD = 0xF986;
static const uint16_t C_BORDER = 0x4208;
struct Rect {
int16_t x;
int16_t y;
int16_t w;
int16_t h;
};
enum class Mode : uint8_t {
ThreeWire,
TwoWire,
};
struct Sample {
uint16_t raw;
uint32_t mv;
uint16_t rawMinBurst;
uint16_t rawMaxBurst;
};
Arduino_DataBus *bus = new Arduino_ESP32SPI(
PIN_LCD_DC, PIN_LCD_CS, PIN_LCD_SCLK, PIN_LCD_MOSI, PIN_LCD_MISO);
Arduino_GFX *gfx = new Arduino_ST7789(
bus, PIN_LCD_RST, 1, true, 240, 320);
static const Rect BTN_3WIRE = {10, 38, 94, 30};
static const Rect BTN_2WIRE = {113, 38, 94, 30};
static const Rect BTN_RESET = {216, 38, 94, 30};
static Mode gMode = Mode::ThreeWire;
static uint32_t gLastUiMs = 0;
static uint32_t gLastSerialMs = 0;
static uint32_t gMinMv = 0xFFFFFFFF;
static uint32_t gMaxMv = 0;
static float gEmaMv = 0.0f;
static bool gHasEma = false;
static bool gTouchOk = false;
static uint16_t gLastTouchX = 0;
static uint16_t gLastTouchY = 0;
static bool gBootWasDown = false;
static uint32_t gBootLastChangeMs = 0;
static void drawText(int16_t x, int16_t y, const char *text, uint16_t color, uint8_t size = 1) {
gfx->setTextSize(size);
gfx->setTextColor(color);
gfx->setCursor(x, y);
gfx->print(text);
}
static void drawButton(const Rect &r, const char *label, bool active) {
uint16_t fill = active ? C_ACCENT : C_CARD;
uint16_t text = active ? C_BG : C_TEXT;
gfx->fillRoundRect(r.x, r.y, r.w, r.h, 6, fill);
gfx->drawRoundRect(r.x, r.y, r.w, r.h, 6, active ? C_ACCENT : C_BORDER);
int16_t tx = r.x + 10;
int16_t ty = r.y + 10;
drawText(tx, ty, label, text, 1);
}
static bool contains(const Rect &r, uint16_t x, uint16_t y) {
return x >= r.x && x < r.x + r.w && y >= r.y && y < r.y + r.h;
}
static const char *modeName() {
return gMode == Mode::ThreeWire ? "3-WIRE" : "2-WIRE";
}
static void resetRange() {
gMinMv = 0xFFFFFFFF;
gMaxMv = 0;
gHasEma = false;
}
static void configurePins() {
pinMode(PIN_ADC_WIPER, INPUT);
analogReadResolution(12);
analogSetPinAttenuation(PIN_ADC_WIPER, ADC_11db);
if (gMode == Mode::TwoWire) {
pinMode(PIN_DRIVE_2WIRE, OUTPUT);
digitalWrite(PIN_DRIVE_2WIRE, HIGH);
pinMode(PIN_ADC_WIPER, INPUT_PULLDOWN);
} else {
pinMode(PIN_DRIVE_2WIRE, INPUT);
pinMode(PIN_ADC_WIPER, INPUT);
}
}
static void setMode(Mode mode) {
if (gMode == mode) return;
gMode = mode;
configurePins();
resetRange();
}
static Sample readSample() {
const uint8_t count = 32;
uint32_t rawSum = 0;
uint32_t mvSum = 0;
uint16_t rawMin = 4095;
uint16_t rawMax = 0;
for (uint8_t i = 0; i < count; i++) {
uint16_t raw = analogRead(PIN_ADC_WIPER);
uint32_t mv = analogReadMilliVolts(PIN_ADC_WIPER);
rawSum += raw;
mvSum += mv;
if (raw < rawMin) rawMin = raw;
if (raw > rawMax) rawMax = raw;
delayMicroseconds(250);
}
Sample s;
s.raw = rawSum / count;
s.mv = mvSum / count;
s.rawMinBurst = rawMin;
s.rawMaxBurst = rawMax;
return s;
}
static uint8_t percentFromMv(uint32_t mv) {
if (mv >= ADC_FULL_MV) return 100;
return (uint8_t)((mv * 100UL + ADC_FULL_MV / 2) / ADC_FULL_MV);
}
static uint8_t calibratedPercent(uint32_t mv, uint32_t span) {
if (span < 10 || gMinMv == 0xFFFFFFFF || mv <= gMinMv) return 0;
uint32_t pct = ((mv - gMinMv) * 100UL + span / 2) / span;
return (uint8_t)min<uint32_t>(pct, 100);
}
static const char *statusText(uint32_t mv, uint32_t span, uint8_t pctAbs) {
if (mv < 30) return "OPEN/GND";
if (mv > 3250) return "SATURATED";
if (span < 20) return "NO SPAN";
if (pctAbs < 15) return "LOW";
if (pctAbs > 85) return "HIGH";
return "MID";
}
static float estimateOhms(uint32_t mv) {
if (gMode == Mode::ThreeWire) {
return POT_OHMS * ((float)percentFromMv(mv) / 100.0f);
}
if (mv < 5) return -1.0f;
if (mv >= ADC_FULL_MV) return 0.0f;
return ROUGH_PULLDOWN_OHMS * ((float)ADC_FULL_MV / (float)mv - 1.0f);
}
static void drawStaticUi() {
gfx->fillScreen(C_BG);
drawText(10, 8, "POT ADC TEST", C_TEXT, 2);
drawText(210, 12, "ESP32-S3-LCD-2", C_MUTE, 1);
drawButton(BTN_3WIRE, "3-WIRE", gMode == Mode::ThreeWire);
drawButton(BTN_2WIRE, "2-WIRE", gMode == Mode::TwoWire);
drawButton(BTN_RESET, "RESET", false);
gfx->drawRoundRect(8, 76, 304, 64, 8, C_BORDER);
gfx->drawRoundRect(8, 148, 304, 54, 8, C_BORDER);
gfx->drawRoundRect(8, 208, 304, 24, 6, C_BORDER);
}
static void drawBar(uint8_t pct, uint16_t color) {
int x = 18;
int y = 123;
int w = 284;
int h = 10;
gfx->fillRect(x, y, w, h, C_BORDER);
gfx->fillRect(x, y, (w * pct) / 100, h, color);
}
static void updateUi() {
Sample s = readSample();
if (s.mv < gMinMv) gMinMv = s.mv;
if (s.mv > gMaxMv) gMaxMv = s.mv;
uint32_t span = (gMaxMv > gMinMv) ? (gMaxMv - gMinMv) : 0;
if (!gHasEma) {
gEmaMv = (float)s.mv;
gHasEma = true;
} else {
gEmaMv = gEmaMv * 0.85f + (float)s.mv * 0.15f;
}
uint8_t pctAbs = percentFromMv(s.mv);
uint8_t pctCal = calibratedPercent(s.mv, span);
float ohms = estimateOhms(s.mv);
const char *status = statusText(s.mv, span, pctAbs);
uint16_t statusColor = strcmp(status, "MID") == 0 ? C_OK :
strcmp(status, "NO SPAN") == 0 ? C_WARN :
strcmp(status, "SATURATED") == 0 ? C_BAD : C_ACCENT;
char line[96];
gfx->fillRect(9, 77, 302, 62, C_BG);
snprintf(line, sizeof(line), "%s ADC=IO2 DRIVE=IO6", modeName());
drawText(16, 84, line, C_ACCENT, 1);
snprintf(line, sizeof(line), "raw:%4u mv:%4lu ema:%4lu",
s.raw, (unsigned long)s.mv, (unsigned long)(gEmaMv + 0.5f));
drawText(16, 101, line, C_TEXT, 1);
snprintf(line, sizeof(line), "abs:%3u%% cal:%3u%% jitter:%u",
pctAbs, pctCal, (unsigned)(s.rawMaxBurst - s.rawMinBurst));
drawText(16, 115, line, C_TEXT, 1);
drawBar(gMode == Mode::ThreeWire ? pctAbs : pctCal, statusColor);
gfx->fillRect(9, 149, 302, 52, C_BG);
snprintf(line, sizeof(line), "min:%4lu max:%4lu span:%4lu mV",
(unsigned long)gMinMv, (unsigned long)gMaxMv, (unsigned long)span);
drawText(16, 156, line, C_TEXT, 1);
if (ohms < 0) {
snprintf(line, sizeof(line), "ohm: open/too high status:%s", status);
} else {
snprintf(line, sizeof(line), "ohm:%6.1fk%s status:%s",
ohms / 1000.0f, gMode == Mode::TwoWire ? " rough" : "", status);
}
drawText(16, 172, line, statusColor, 1);
snprintf(line, sizeof(line), "touch:%s x:%u y:%u serial:m/r",
gTouchOk ? "ok" : "off", gLastTouchX, gLastTouchY);
drawText(16, 188, line, C_MUTE, 1);
gfx->fillRect(9, 209, 302, 22, C_BG);
if (gMode == Mode::ThreeWire) {
drawText(16, 216, "Wire: 3V3-edge GND-edge IO2-wiper", C_MUTE, 1);
} else {
drawText(16, 216, "Wire: IO6-edge IO2-wiper third pin open", C_MUTE, 1);
}
Serial.printf("mode=%s raw=%u mv=%lu ema=%.1f abs=%u cal=%u min=%lu max=%lu span=%lu jitter=%u status=%s\n",
modeName(), s.raw, (unsigned long)s.mv, gEmaMv, pctAbs, pctCal,
(unsigned long)gMinMv, (unsigned long)gMaxMv, (unsigned long)span,
(unsigned)(s.rawMaxBurst - s.rawMinBurst), status);
}
static void handleTouch() {
bsp_touch_read();
uint16_t x = 0;
uint16_t y = 0;
if (!bsp_touch_get_coordinates(&x, &y)) return;
gLastTouchX = x;
gLastTouchY = y;
if (contains(BTN_3WIRE, x, y)) {
setMode(Mode::ThreeWire);
drawStaticUi();
} else if (contains(BTN_2WIRE, x, y)) {
setMode(Mode::TwoWire);
drawStaticUi();
} else if (contains(BTN_RESET, x, y)) {
resetRange();
}
}
static void handleBootButton() {
bool down = digitalRead(PIN_BOOT_BUTTON) == LOW;
uint32_t now = millis();
if (down != gBootWasDown && now - gBootLastChangeMs > 40) {
gBootWasDown = down;
gBootLastChangeMs = now;
if (!down) {
setMode(gMode == Mode::ThreeWire ? Mode::TwoWire : Mode::ThreeWire);
drawStaticUi();
}
}
}
static void handleSerial() {
while (Serial.available() > 0) {
char c = (char)Serial.read();
if (c == 'm' || c == 'M') {
setMode(gMode == Mode::ThreeWire ? Mode::TwoWire : Mode::ThreeWire);
drawStaticUi();
} else if (c == 'r' || c == 'R') {
resetRange();
}
}
}
void setup() {
Serial.begin(115200);
delay(100);
Serial.println("ESP32-S3-LCD-2 potentiometer ADC test");
Serial.println("Commands: m=switch mode, r=reset min/max");
pinMode(PIN_BOOT_BUTTON, INPUT_PULLUP);
configurePins();
if (!gfx->begin()) {
Serial.println("gfx->begin() failed");
}
pinMode(PIN_LCD_BL, OUTPUT);
digitalWrite(PIN_LCD_BL, HIGH);
Wire.begin(PIN_TP_SDA, PIN_TP_SCL);
gTouchOk = bsp_touch_init(&Wire, 1, DISP_W, DISP_H);
drawStaticUi();
}
void loop() {
handleSerial();
handleBootButton();
if (gTouchOk) handleTouch();
uint32_t now = millis();
if (now - gLastUiMs >= 250) {
updateUi();
gLastUiMs = now;
}
if (now - gLastSerialMs >= 5000) {
Serial.println("Hint: m switches 3-WIRE/2-WIRE, r resets min/max. Never feed 5V into IO2/IO6.");
gLastSerialMs = now;
}
}
@@ -47,20 +47,24 @@ case "${MODE}" in
lvgl-official-based-test) SKETCH_DIR="${ROOT_DIR}/test_sketches/lvgl_official_based_test" ;;
lvgl-subserver-touch-test) SKETCH_DIR="${ROOT_DIR}/test_sketches/lvgl_subserver_touch_test" ;;
lvgl-russian-font-test) SKETCH_DIR="${ROOT_DIR}/test_sketches/lvgl_russian_font_test" ;;
usb-contact-test) SKETCH_DIR="${ROOT_DIR}/test_sketches/usb_contact_sensor_test" ;;
usb-contact-debug-test) SKETCH_DIR="${ROOT_DIR}/test_sketches/usb_contact_sensor_debug_test" ;;
usb-contact-resistance-test) SKETCH_DIR="${ROOT_DIR}/test_sketches/usb_contact_resistance_test" ;;
usb-contact-screen-start-stub) SKETCH_DIR="${ROOT_DIR}/test_sketches/usb_contact_screen_start_stub" ;;
lvgl-nav-minimal-test) SKETCH_DIR="${ROOT_DIR}/shine_homeserver_main" ;;
*)
echo "Unknown mode: ${MODE}" >&2
echo "Use one of: hello, widgets, audio, simple, argon2, homeserver-ui, shine-homeserver-main, shine-homeserver-ui-main, legacy-homeserver-ui, text-test, gfx-text-test, gfx-layout-test, lvgl-basic-test, lvgl-interaction-test, lvgl-touch-debug-test, lvgl-official-based-test, lvgl-subserver-touch-test, lvgl-russian-font-test, usb-contact-test, usb-contact-debug-test, usb-contact-resistance-test, usb-contact-screen-start-stub" >&2
echo "Use one of: hello, widgets, audio, simple, argon2, homeserver-ui, shine-homeserver-main, shine-homeserver-ui-main, legacy-homeserver-ui, text-test, gfx-text-test, gfx-layout-test, lvgl-basic-test, lvgl-interaction-test, lvgl-touch-debug-test, lvgl-official-based-test, lvgl-subserver-touch-test, lvgl-russian-font-test" >&2
exit 2
;;
esac
if [[ -z "${PORT}" ]]; then
if ! PORT="$(detect_port)"; then
echo "Failed to auto-detect ESP32 port. Set PORT=/dev/ttyACM0 ./burn.sh ${MODE}" >&2
exit 3
fi
fi
echo "== Mode: ${MODE}"
echo "== Sketch: ${SKETCH_DIR}"
echo "== Port: ${PORT}"
echo "== FQBN: ${FQBN}"
mkdir -p "${BUILD_DIR}" "${OUT_DIR}"
@@ -74,7 +78,6 @@ compile_args=(
--library "${DEMO_BASE}/libraries/XPowersLib"
--library "${DEMO_BASE}/libraries/lvgl"
--library "${DEMO_BASE}/libraries/Mylibrary"
--library "${ROOT_DIR}/simple_av_test"
"${SKETCH_DIR}"
)
@@ -84,20 +87,6 @@ if ! arduino-cli compile "${compile_args[@]}"; then
arduino-cli compile --clean "${compile_args[@]}"
fi
if [[ "${NO_UPLOAD:-0}" == "1" ]]; then
echo "== Done: compiled without upload (NO_UPLOAD=1)."
exit 0
fi
if [[ -z "${PORT}" ]]; then
if ! PORT="$(detect_port)"; then
echo "Failed to auto-detect ESP32 port. Set PORT=/dev/ttyACM0 ./burn.sh ${MODE}" >&2
exit 3
fi
fi
echo "== Port: ${PORT}"
arduino-cli upload \
-p "${PORT}" \
--fqbn "${FQBN}" \
@@ -15,9 +15,6 @@
- `lvgl_official_based_test/` - минимальный наш экран поверх максимально близкой к официальному `05_LVGL_Widgets` инициализации
- `lvgl_subserver_touch_test/` - старый гибридный тест: `LVGL`-экран с инициализацией дисплея и чтением touch из старого `shine_homeserver_ui`; подтверждён на реальном устройстве
- `lvgl_russian_font_test/` - тест кастомного кириллического `LVGL`-шрифта с русскими кнопками, длинными строками и рабочим touch
- `usb_contact_sensor_test/` - тест переключения нативных USB D-/D+ (`GPIO19/20`) в режим простого замыкаемого контакта после нажатия Start; после перезагрузки снова обычный USB
- `usb_contact_sensor_debug_test/` - debug-версия теста замыкания контакта: экранная кнопка проверяет touch, а переход в sensor mode выполняется физической кнопкой BOOT
- `usb_contact_resistance_test/` - тест измерения сопротивления между USB D-/D+ через ADC на GPIO20; рассчитан на внешний известный резистор 10 kΩ с D+ на GND
- `lvgl_nav_minimal_test/` - старое тестовое имя, этот скетч перенесён в `shine_homeserver_main/` и теперь является основным
## Запуск
@@ -32,6 +29,3 @@
- `./burn.sh lvgl-official-based-test`
- `./burn.sh lvgl-subserver-touch-test`
- `./burn.sh lvgl-russian-font-test`
- `./burn.sh usb-contact-test`
- `./burn.sh usb-contact-debug-test`
- `./burn.sh usb-contact-resistance-test`
@@ -1,295 +0,0 @@
#include <Arduino.h>
#include <Wire.h>
#include <lvgl.h>
#include <Arduino_GFX_Library.h>
#include "pin_config.h"
#include "TouchDrvCSTXXX.hpp"
#define EXAMPLE_LVGL_TICK_PERIOD_MS 2
// ESP32-S3 native USB data pins.
static constexpr int kUsbDmPin = 19; // USB D-
static constexpr int kUsbDpPin = 20; // USB D+, ADC input in resistance mode.
static constexpr uint32_t kUiRefreshMs = 120;
static constexpr uint32_t kAdcSamples = 32;
// For a stable ohm reading connect a known resistor from D+ / GPIO20 to GND.
// The measured resistance must be connected between D- / GPIO19 and D+ / GPIO20.
static constexpr float kKnownPulldownOhms = 10000.0f;
static constexpr float kSourceMillivolts = 3300.0f;
static constexpr float kOpenThresholdMillivolts = 25.0f;
static lv_disp_draw_buf_t gDrawBuf;
static lv_color_t *gBuf1 = nullptr;
static lv_color_t *gBuf2 = nullptr;
static lv_obj_t *gModeLabel = nullptr;
static lv_obj_t *gResistanceLabel = nullptr;
static lv_obj_t *gRawLabel = nullptr;
static lv_obj_t *gHintLabel = nullptr;
static lv_obj_t *gActionButton = nullptr;
static lv_obj_t *gActionButtonLabel = nullptr;
static TouchDrvCST92xx gTouch;
static int16_t gTouchX[5];
static int16_t gTouchY[5];
static bool gSensorMode = false;
static uint32_t gLastUiRefreshMs = 0;
Arduino_DataBus *gBus = new Arduino_ESP32QSPI(
LCD_CS, LCD_SCLK, LCD_SDIO0, LCD_SDIO1, LCD_SDIO2, LCD_SDIO3);
Arduino_CO5300 *gfx = new Arduino_CO5300(
gBus, LCD_RESET, 0, LCD_WIDTH, LCD_HEIGHT, 0, 0, 0, 0);
static void lvglFlushCb(lv_disp_drv_t *disp, const lv_area_t *area, lv_color_t *colorP) {
uint32_t w = area->x2 - area->x1 + 1;
uint32_t h = area->y2 - area->y1 + 1;
#if (LV_COLOR_16_SWAP != 0)
gfx->draw16bitBeRGBBitmap(area->x1, area->y1, (uint16_t *)&colorP->full, w, h);
#else
gfx->draw16bitRGBBitmap(area->x1, area->y1, (uint16_t *)&colorP->full, w, h);
#endif
lv_disp_flush_ready(disp);
}
static void lvglTick(void *arg) {
LV_UNUSED(arg);
lv_tick_inc(EXAMPLE_LVGL_TICK_PERIOD_MS);
}
static void lvglTouchRead(lv_indev_drv_t *indevDrv, lv_indev_data_t *data) {
LV_UNUSED(indevDrv);
uint8_t touched = gTouch.getPoint(gTouchX, gTouchY, gTouch.getSupportTouchPoint());
if (touched > 0) {
data->state = LV_INDEV_STATE_PR;
data->point.x = gTouchX[0];
data->point.y = gTouchY[0];
return;
}
data->state = LV_INDEV_STATE_REL;
}
static uint32_t readAverageRaw() {
uint32_t sum = 0;
for (uint32_t i = 0; i < kAdcSamples; i++) {
sum += analogRead(kUsbDpPin);
delayMicroseconds(250);
}
return sum / kAdcSamples;
}
static uint32_t readAverageMillivolts() {
uint32_t sum = 0;
for (uint32_t i = 0; i < kAdcSamples; i++) {
sum += analogReadMilliVolts(kUsbDpPin);
delayMicroseconds(250);
}
return sum / kAdcSamples;
}
static void setResistanceText(float ohms) {
if (ohms >= 1000000.0f) {
String text = String(ohms / 1000000.0f, 2) + " Mohm";
lv_label_set_text(gResistanceLabel, text.c_str());
} else if (ohms >= 1000.0f) {
String text = String(ohms / 1000.0f, 2) + " kohm";
lv_label_set_text(gResistanceLabel, text.c_str());
} else {
String text = String(ohms, 0) + " ohm";
lv_label_set_text(gResistanceLabel, text.c_str());
}
}
static void updateResistanceUi() {
if (!gSensorMode) {
return;
}
uint32_t now = millis();
if (now - gLastUiRefreshMs < kUiRefreshMs) {
return;
}
gLastUiRefreshMs = now;
uint32_t raw = readAverageRaw();
uint32_t millivolts = readAverageMillivolts();
if (millivolts <= kOpenThresholdMillivolts) {
lv_label_set_text(gResistanceLabel, "OPEN");
lv_obj_set_style_text_color(gResistanceLabel, lv_color_hex(0xFFD166), 0);
} else if (millivolts >= (uint32_t)(kSourceMillivolts - 80.0f)) {
lv_label_set_text(gResistanceLabel, "SHORT / LOW");
lv_obj_set_style_text_color(gResistanceLabel, lv_color_hex(0x7CFF8A), 0);
} else {
float rx = kKnownPulldownOhms * ((kSourceMillivolts / (float)millivolts) - 1.0f);
lv_obj_set_style_text_color(gResistanceLabel, lv_color_hex(0x7CFF8A), 0);
setResistanceText(rx);
}
String rawText = "ADC raw: " + String(raw);
rawText += "\nD+ voltage: " + String(millivolts) + " mV";
rawText += "\nKnown pulldown: 10 kohm to GND";
lv_label_set_text(gRawLabel, rawText.c_str());
}
static void enterSensorMode() {
Serial.flush();
delay(30);
pinMode(kUsbDmPin, OUTPUT);
digitalWrite(kUsbDmPin, HIGH);
pinMode(kUsbDpPin, INPUT);
analogReadResolution(12);
analogSetPinAttenuation(kUsbDpPin, ADC_11db);
gSensorMode = true;
gLastUiRefreshMs = 0;
lv_label_set_text(gModeLabel, "Resistance mode");
lv_label_set_text(gHintLabel, "D- is 3.3V source. D+ is ADC input.\nUse 10 kohm from D+ to GND for accurate readings.");
lv_label_set_text(gActionButtonLabel, "Restart to USB");
updateResistanceUi();
}
static void actionButtonEventCb(lv_event_t *event) {
if (lv_event_get_code(event) != LV_EVENT_CLICKED) {
return;
}
if (!gSensorMode) {
enterSensorMode();
return;
}
lv_label_set_text(gModeLabel, "Restarting...");
lv_label_set_text(gHintLabel, "USB mode will return after reboot.");
lv_timer_handler();
delay(150);
ESP.restart();
}
static void createUi() {
lv_obj_t *screen = lv_scr_act();
lv_obj_set_style_bg_color(screen, lv_color_hex(0x0B1320), 0);
lv_obj_set_style_bg_opa(screen, LV_OPA_COVER, 0);
lv_obj_t *title = lv_label_create(screen);
lv_label_set_text(title, "USB RESISTANCE TEST");
lv_obj_set_style_text_color(title, lv_color_hex(0xFFFFFF), 0);
lv_obj_set_style_text_font(title, &lv_font_montserrat_22, 0);
lv_obj_align(title, LV_ALIGN_TOP_MID, 0, 24);
gModeLabel = lv_label_create(screen);
lv_label_set_text(gModeLabel, "USB mode");
lv_obj_set_style_text_color(gModeLabel, lv_color_hex(0xB8C8DC), 0);
lv_obj_set_style_text_font(gModeLabel, &lv_font_montserrat_18, 0);
lv_obj_align(gModeLabel, LV_ALIGN_TOP_MID, 0, 68);
gResistanceLabel = lv_label_create(screen);
lv_label_set_text(gResistanceLabel, "READY");
lv_obj_set_style_text_color(gResistanceLabel, lv_color_hex(0x72D6FF), 0);
lv_obj_set_style_text_font(gResistanceLabel, &lv_font_montserrat_40, 0);
lv_obj_align(gResistanceLabel, LV_ALIGN_CENTER, 0, -72);
gRawLabel = lv_label_create(screen);
lv_label_set_text(gRawLabel, "ADC raw: -\nD+ voltage: -\nKnown pulldown: 10 kohm to GND");
lv_obj_set_width(gRawLabel, 420);
lv_label_set_long_mode(gRawLabel, LV_LABEL_LONG_WRAP);
lv_obj_set_style_text_align(gRawLabel, LV_TEXT_ALIGN_CENTER, 0);
lv_obj_set_style_text_color(gRawLabel, lv_color_hex(0xD5DCE5), 0);
lv_obj_set_style_text_font(gRawLabel, &lv_font_montserrat_16, 0);
lv_obj_align(gRawLabel, LV_ALIGN_CENTER, 0, -8);
gHintLabel = lv_label_create(screen);
lv_label_set_text(gHintLabel, "USB is normal now.\nTap Start to measure resistance between D- and D+.");
lv_obj_set_width(gHintLabel, 420);
lv_label_set_long_mode(gHintLabel, LV_LABEL_LONG_WRAP);
lv_obj_set_style_text_align(gHintLabel, LV_TEXT_ALIGN_CENTER, 0);
lv_obj_set_style_text_color(gHintLabel, lv_color_hex(0xAAB7C6), 0);
lv_obj_set_style_text_font(gHintLabel, &lv_font_montserrat_14, 0);
lv_obj_align(gHintLabel, LV_ALIGN_CENTER, 0, 72);
gActionButton = lv_btn_create(screen);
lv_obj_set_size(gActionButton, 260, 72);
lv_obj_align(gActionButton, LV_ALIGN_BOTTOM_MID, 0, -42);
lv_obj_set_style_radius(gActionButton, 18, 0);
lv_obj_set_style_bg_color(gActionButton, lv_color_hex(0x2A9D8F), 0);
lv_obj_set_style_border_width(gActionButton, 0, 0);
lv_obj_add_event_cb(gActionButton, actionButtonEventCb, LV_EVENT_CLICKED, nullptr);
gActionButtonLabel = lv_label_create(gActionButton);
lv_label_set_text(gActionButtonLabel, "Start");
lv_obj_set_style_text_color(gActionButtonLabel, lv_color_hex(0xFFFFFF), 0);
lv_obj_set_style_text_font(gActionButtonLabel, &lv_font_montserrat_22, 0);
lv_obj_center(gActionButtonLabel);
}
void setup() {
Serial.begin(115200);
Wire.begin(IIC_SDA, IIC_SCL);
pinMode(TP_RST, OUTPUT);
pinMode(TP_INT, INPUT);
digitalWrite(TP_RST, LOW);
delay(30);
digitalWrite(TP_RST, HIGH);
delay(50);
delay(1000);
gTouch.setPins(TP_RST, TP_INT);
bool touchOk = gTouch.begin(Wire, 0x5A, IIC_SDA, IIC_SCL);
if (!touchOk) {
Serial.println("Touch init failed");
} else {
gTouch.sleep();
gTouch.reset();
gTouch.setMaxCoordinates(480, 480);
gTouch.setSwapXY(true);
gTouch.setMirrorXY(true, false);
}
gfx->begin();
gBus->writeC8D8(0x36, 0xA0);
gfx->setBrightness(220);
gfx->fillScreen(0x0000);
lv_init();
uint32_t screenWidth = gfx->width();
uint32_t screenHeight = gfx->height();
gBuf1 = (lv_color_t *)heap_caps_malloc(screenWidth * screenHeight / 4 * sizeof(lv_color_t), MALLOC_CAP_DMA);
gBuf2 = (lv_color_t *)heap_caps_malloc(screenWidth * screenHeight / 4 * sizeof(lv_color_t), MALLOC_CAP_DMA);
lv_disp_draw_buf_init(&gDrawBuf, gBuf1, gBuf2, screenWidth * screenHeight / 4);
static lv_disp_drv_t dispDrv;
lv_disp_drv_init(&dispDrv);
dispDrv.hor_res = screenWidth;
dispDrv.ver_res = screenHeight;
dispDrv.flush_cb = lvglFlushCb;
dispDrv.draw_buf = &gDrawBuf;
lv_disp_drv_register(&dispDrv);
static lv_indev_drv_t indevDrv;
lv_indev_drv_init(&indevDrv);
indevDrv.type = LV_INDEV_TYPE_POINTER;
indevDrv.read_cb = lvglTouchRead;
lv_indev_drv_register(&indevDrv);
const esp_timer_create_args_t lvglTickTimerArgs = {
.callback = &lvglTick,
.name = "lvgl_tick"};
esp_timer_handle_t lvglTickTimer = nullptr;
esp_timer_create(&lvglTickTimerArgs, &lvglTickTimer);
esp_timer_start_periodic(lvglTickTimer, EXAMPLE_LVGL_TICK_PERIOD_MS * 1000);
createUi();
Serial.println("USB resistance test ready; native USB remains active until Start is tapped.");
}
void loop() {
updateResistanceUi();
lv_timer_handler();
delay(5);
}
@@ -1,600 +0,0 @@
#include <Arduino.h>
#include <Wire.h>
#include <math.h>
#include <Preferences.h>
#include <Arduino_GFX_Library.h>
#include <TouchDrvCSTXXX.hpp>
#include "ESP_I2S.h"
#include "es8311.h"
#define PIN_LCD_CS 12
#define PIN_LCD_SCLK 38
#define PIN_LCD_D0 4
#define PIN_LCD_D1 5
#define PIN_LCD_D2 6
#define PIN_LCD_D3 7
#define PIN_LCD_RST 2
#define PIN_I2C_SDA 15
#define PIN_I2C_SCL 14
#define PIN_TP_INT 11
#define PIN_USER_BTN 0
#define PIN_PA 46
#define PIN_I2S_BCLK 9
#define PIN_I2S_LRCK 45
#define PIN_I2S_DOUT 8
#define PIN_I2S_DIN 10
#define PIN_I2S_MCLK 42
#define DISP_W 480
#define DISP_H 480
static constexpr int kUsbDmPin = 19;
static constexpr int kUsbDpPin = 20;
static constexpr uint32_t kContactDebounceMs = 80;
static constexpr uint32_t kButtonDebounceMs = 45;
static constexpr uint32_t kUiPeriodMs = 200;
static constexpr uint32_t kSampleRate = 16000;
static constexpr uint32_t kMinCycleMs = 1500;
static constexpr uint32_t kPauseAfterMs = 60000;
#define C_BG 0x0841u
#define C_PANEL 0x1082u
#define C_CARD 0x18C3u
#define C_BORDER 0x39C7u
#define C_TEXT 0xFFFFu
#define C_MUTE 0xBDF7u
#define C_ACCENT 0x5D5Fu
#define C_OK 0x3666u
#define C_BAD 0xD145u
#define C_BUTTON 0x2145u
Arduino_DataBus *gBus = new Arduino_ESP32QSPI(
PIN_LCD_CS, PIN_LCD_SCLK, PIN_LCD_D0, PIN_LCD_D1, PIN_LCD_D2, PIN_LCD_D3);
Arduino_CO5300 *gfx = new Arduino_CO5300(
gBus, PIN_LCD_RST, 0, DISP_W, DISP_H, 0, 0, 0, 0);
TouchDrvCST92xx gTouch;
I2SClass gI2s;
Preferences gPrefs;
struct Rect {
int16_t x;
int16_t y;
int16_t w;
int16_t h;
};
static const Rect kStartButton = {96, 348, 288, 78};
static const Rect kLimitSlider = {42, 132, 396, 44};
static const Rect kTickSlider = {42, 246, 396, 44};
static const Rect kAlertSlider = {42, 360, 396, 44};
static const uint16_t kLimitsSec[] = {5, 7, 10, 15, 20};
static const int16_t kTickAmpByVolume[] = {0, 40, 80, 140, 220, 320, 440, 580, 720, 800, 1600};
static const int16_t kAlertAmpByVolume[] = {0, 150, 300, 500, 800, 12000, 12000, 12000, 12000, 12000, 12000};
static bool gStarted = false;
static bool gSettingsOpen = false;
static bool gAudioReady = false;
static bool gStableClosed = false;
static bool gLastRawClosed = false;
static bool gStaticDrawn = false;
static bool gNeedRedraw = true;
static bool gNeedStaticRedraw = true;
static bool gLastDrawnClosed = false;
static bool gLastDrawnPaused = false;
static bool gTouchDown = false;
static bool gUserButtonDown = false;
static int16_t gTouchStartX = 0;
static int16_t gTouchStartY = 0;
static int16_t gTouchLastX = 0;
static int16_t gTouchLastY = 0;
static uint32_t gLastRawChangeMs = 0;
static uint32_t gStartedMs = 0;
static uint32_t gLastCycleStartMs = 0;
static uint32_t gLastUiMs = 0;
static uint32_t gUserButtonChangeMs = 0;
static uint32_t gCycleMs[5] = {};
static uint8_t gCycleCount = 0;
static uint8_t gCycleNext = 0;
static uint8_t gLimitIndex = 2;
static uint8_t gTickVolume = 3;
static uint8_t gAlertVolume = 10;
static uint8_t gShortStreak = 0;
static char gLastTopLine[48] = "";
static char gLastStreakLine[48] = "";
static void drawPanel(int x, int y, int w, int h, uint16_t fill, uint16_t border, int radius = 10) {
gfx->fillRoundRect(x, y, w, h, radius, fill);
gfx->drawRoundRect(x, y, w, h, radius, border);
}
static void drawText(int x, int y, const char *text, uint16_t color, uint8_t size = 2) {
gfx->setFont();
gfx->setTextSize(size);
gfx->setTextColor(color);
gfx->setCursor(x, y);
gfx->print(text);
}
static void drawCenteredText(int x, int y, int w, const char *text, uint16_t color, uint8_t size = 2) {
int textW = strlen(text) * 6 * size;
int textX = x + (w - textW) / 2;
if (textX < x + 8) {
textX = x + 8;
}
drawText(textX, y, text, color, size);
}
static void drawButton(const Rect &rect, const char *label, uint8_t size = 2) {
drawPanel(rect.x, rect.y, rect.w, rect.h, C_BUTTON, C_BORDER, 12);
drawCenteredText(rect.x, rect.y + 18, rect.w, label, C_TEXT, size);
}
static bool contains(const Rect &rect, int16_t x, int16_t y) {
return x >= rect.x && x < rect.x + rect.w && y >= rect.y && y < rect.y + rect.h;
}
static void clearArea(int x, int y, int w, int h, uint16_t fill) {
gfx->fillRect(x, y, w, h, fill);
}
static void formatSec(char *out, size_t outSize, uint32_t ms) {
snprintf(out, outSize, "%lu.%01lus", (unsigned long)(ms / 1000), (unsigned long)((ms % 1000) / 100));
}
static void formatClock(char *out, size_t outSize, uint32_t ms) {
uint32_t sec = ms / 1000;
snprintf(out, outSize, "%02lu:%02lu", (unsigned long)(sec / 60), (unsigned long)(sec % 60));
}
static uint32_t averageCycleMs() {
if (gCycleCount == 0) {
return 0;
}
uint32_t sum = 0;
for (uint8_t i = 0; i < gCycleCount; i++) {
sum += gCycleMs[i];
}
return sum / gCycleCount;
}
static void resetCachedUiText() {
gLastTopLine[0] = '\0';
gLastStreakLine[0] = '\0';
}
static void loadSettings() {
gPrefs.begin("breath-mon", false);
gLimitIndex = gPrefs.getUChar("limit", gLimitIndex);
gTickVolume = gPrefs.getUChar("tick", gTickVolume);
gAlertVolume = gPrefs.getUChar("alert", gAlertVolume);
if (gLimitIndex > 4) {
gLimitIndex = 2;
}
if (gTickVolume > 10) {
gTickVolume = 3;
}
if (gAlertVolume > 10) {
gAlertVolume = 10;
}
}
static void saveSettings() {
gPrefs.putUChar("limit", gLimitIndex);
gPrefs.putUChar("tick", gTickVolume);
gPrefs.putUChar("alert", gAlertVolume);
}
static bool isAutoPaused() {
return gStarted && gLastCycleStartMs != 0 && (millis() - gLastCycleStartMs) > kPauseAfterMs;
}
static esp_err_t codecInit() {
es8311_handle_t esHandle = es8311_create(0, ES8311_ADDRRES_0);
if (!esHandle) {
return ESP_FAIL;
}
const es8311_clock_config_t clk = {
.mclk_inverted = false,
.sclk_inverted = false,
.mclk_from_mclk_pin = true,
.mclk_frequency = (int)kSampleRate * 256,
.sample_frequency = (int)kSampleRate,
};
if (es8311_init(esHandle, &clk, ES8311_RESOLUTION_16, ES8311_RESOLUTION_16) != ESP_OK) {
return ESP_FAIL;
}
es8311_voice_volume_set(esHandle, 100, nullptr);
es8311_voice_mute(esHandle, false);
return ESP_OK;
}
static void initAudio() {
pinMode(PIN_PA, OUTPUT);
digitalWrite(PIN_PA, HIGH);
gI2s.setPins(PIN_I2S_BCLK, PIN_I2S_LRCK, PIN_I2S_DOUT, PIN_I2S_DIN, PIN_I2S_MCLK);
if (!gI2s.begin(I2S_MODE_STD, kSampleRate, I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_STEREO, I2S_STD_SLOT_BOTH)) {
Serial.println("I2S init failed");
return;
}
gAudioReady = (codecInit() == ESP_OK);
Serial.println(gAudioReady ? "Audio init OK" : "Audio codec init failed");
}
static void playBeep(uint16_t freq, uint16_t samples, int16_t amp) {
if (!gAudioReady || amp <= 0) {
return;
}
static int16_t toneBuf[1600 * 2];
if (samples > 1600) {
samples = 1600;
}
for (int i = 0; i < samples; i++) {
float s = sinf(2.0f * 3.1415926f * (float)freq * ((float)i / (float)kSampleRate));
int16_t v = (int16_t)(s * amp);
toneBuf[i * 2] = v;
toneBuf[i * 2 + 1] = v;
}
gI2s.write((uint8_t *)toneBuf, samples * 2 * sizeof(int16_t));
}
static void playCycleTick() {
playBeep(880, 480, kTickAmpByVolume[gTickVolume]);
}
static void playAlertBeep() {
playBeep(1200, 1600, kAlertAmpByVolume[gAlertVolume]);
}
static void alertIfNeeded() {
if (gShortStreak == 0) {
return;
}
uint8_t count = min<uint8_t>(gShortStreak, 5);
for (uint8_t i = 0; i < count; i++) {
playAlertBeep();
delay(80);
}
}
static void addCycle(uint32_t cycleMs) {
gCycleMs[gCycleNext] = cycleMs;
gCycleNext = (gCycleNext + 1) % 5;
if (gCycleCount < 5) {
gCycleCount++;
}
uint32_t avgMs = averageCycleMs();
if (avgMs > 0 && avgMs < (uint32_t)kLimitsSec[gLimitIndex] * 1000UL) {
if (gShortStreak < 5) {
gShortStreak++;
}
} else {
gShortStreak = 0;
}
}
static void drawReadyScreen() {
gfx->fillScreen(C_BG);
drawPanel(12, 12, 456, 456, C_PANEL, C_BORDER, 16);
drawText(28, 42, "BREATH MONITOR", C_TEXT, 3);
drawText(28, 78, "USB contact sensor", C_MUTE, 2);
drawPanel(34, 132, 412, 160, C_CARD, C_BORDER, 14);
drawCenteredText(34, 166, 412, "READY", C_ACCENT, 4);
drawCenteredText(34, 222, 412, "Closed = exhale", C_TEXT, 2);
drawCenteredText(34, 252, 412, "Open = inhale", C_MUTE, 2);
drawButton(kStartButton, "START", 3);
}
static void drawSlider(const Rect &rect, const char *title, const char *value, uint8_t pos, uint8_t maxPos) {
drawText(rect.x, rect.y - 28, title, C_TEXT, 2);
drawText(rect.x + 278, rect.y - 28, value, C_ACCENT, 2);
drawPanel(rect.x, rect.y, rect.w, rect.h, C_BUTTON, C_BORDER, 12);
int trackX = rect.x + 22;
int trackW = rect.w - 44;
int trackY = rect.y + rect.h / 2 - 3;
gfx->fillRect(trackX, trackY, trackW, 6, C_BORDER);
int knobX = trackX + (trackW * pos) / max<uint8_t>(1, maxPos);
gfx->fillRoundRect(knobX - 10, rect.y + 8, 20, rect.h - 16, 8, C_ACCENT);
}
static void drawSettingsScreen() {
char value[24];
gfx->fillScreen(C_BG);
drawPanel(12, 12, 456, 456, C_PANEL, C_BORDER, 16);
drawText(28, 36, "SETTINGS", C_TEXT, 3);
drawText(28, 72, "Press top button to close", C_MUTE, 2);
snprintf(value, sizeof(value), "%us", kLimitsSec[gLimitIndex]);
drawSlider(kLimitSlider, "Limit", value, gLimitIndex, 4);
snprintf(value, sizeof(value), "%u/10", gTickVolume);
drawSlider(kTickSlider, "Cycle tick volume", value, gTickVolume, 10);
snprintf(value, sizeof(value), "%u/10", gAlertVolume);
drawSlider(kAlertSlider, "Alert volume", value, gAlertVolume, 10);
gStaticDrawn = false;
gNeedStaticRedraw = true;
}
static void drawMonitorStatic() {
gfx->fillScreen(C_BG);
drawPanel(12, 12, 456, 456, C_PANEL, C_BORDER, 16);
drawText(28, 32, "BREATH MONITOR", C_TEXT, 2);
drawPanel(28, 96, 424, 104, C_CARD, C_BORDER, 14);
drawPanel(28, 216, 200, 72, C_CARD, C_BORDER, 10);
drawText(42, 236, "Current", C_MUTE, 1);
drawPanel(252, 216, 200, 72, C_CARD, C_BORDER, 10);
drawText(266, 236, "Average 5", C_MUTE, 1);
drawPanel(28, 304, 200, 64, C_CARD, C_BORDER, 10);
drawText(42, 322, "From start", C_MUTE, 1);
drawPanel(252, 304, 200, 64, C_CARD, C_BORDER, 10);
drawText(266, 322, "Limit", C_MUTE, 1);
gStaticDrawn = true;
gLastDrawnClosed = !gStableClosed;
gLastDrawnPaused = !isAutoPaused();
resetCachedUiText();
}
static void updateMonitorValues(bool force) {
char line[48];
char value[16];
uint32_t now = millis();
uint32_t runMs = now - gStartedMs;
uint32_t currentMs = (gLastCycleStartMs == 0) ? 0 : now - gLastCycleStartMs;
bool paused = isAutoPaused();
if (paused) {
currentMs = now - gLastCycleStartMs - kPauseAfterMs;
}
uint32_t avgMs = averageCycleMs();
if (force || gLastDrawnClosed != gStableClosed || gLastDrawnPaused != paused) {
clearArea(42, 118, 396, 68, C_CARD);
if (paused) {
drawCenteredText(28, 122, 424, "PAUSE", C_BAD, 4);
drawCenteredText(28, 172, 424, "no cycle for 60s", C_MUTE, 2);
} else {
drawCenteredText(28, 122, 424, gStableClosed ? "EXHALE" : "INHALE",
gStableClosed ? C_OK : C_ACCENT, 4);
drawCenteredText(28, 172, 424, gStableClosed ? "contact closed" : "contact open", C_MUTE, 2);
}
gLastDrawnClosed = gStableClosed;
gLastDrawnPaused = paused;
}
snprintf(line, sizeof(line), "Limit: %us top button: settings", kLimitsSec[gLimitIndex]);
if (strcmp(line, gLastTopLine) != 0) {
clearArea(28, 58, 424, 28, C_PANEL);
drawText(28, 60, line, C_MUTE, 2);
strncpy(gLastTopLine, line, sizeof(gLastTopLine) - 1);
gLastTopLine[sizeof(gLastTopLine) - 1] = '\0';
}
clearArea(42, 254, 160, 28, C_CARD);
formatSec(value, sizeof(value), currentMs);
drawText(42, 256, value, C_TEXT, 3);
clearArea(266, 254, 160, 28, C_CARD);
if (avgMs > 0) {
formatSec(value, sizeof(value), avgMs);
} else {
snprintf(value, sizeof(value), "--");
}
drawText(266, 256, value, C_TEXT, 3);
clearArea(42, 340, 160, 24, C_CARD);
formatClock(value, sizeof(value), runMs);
drawText(42, 342, value, C_TEXT, 2);
clearArea(266, 340, 160, 24, C_CARD);
snprintf(value, sizeof(value), "%us", kLimitsSec[gLimitIndex]);
drawText(266, 342, value, C_TEXT, 2);
snprintf(line, sizeof(line), "Short avg streak: %u", gShortStreak);
if (strcmp(line, gLastStreakLine) != 0) {
clearArea(28, 398, 280, 28, C_PANEL);
drawText(32, 402, line, gShortStreak > 0 ? C_BAD : C_MUTE, 2);
strncpy(gLastStreakLine, line, sizeof(gLastStreakLine) - 1);
gLastStreakLine[sizeof(gLastStreakLine) - 1] = '\0';
}
}
static void redrawScreen() {
if (gSettingsOpen) {
drawSettingsScreen();
} else if (gStarted) {
if (gNeedStaticRedraw || !gStaticDrawn) {
drawMonitorStatic();
gNeedStaticRedraw = false;
}
updateMonitorValues(true);
} else {
drawReadyScreen();
}
gNeedRedraw = false;
gLastUiMs = millis();
}
static void enterSensorMode() {
Serial.flush();
delay(30);
pinMode(kUsbDmPin, OUTPUT);
digitalWrite(kUsbDmPin, LOW);
pinMode(kUsbDpPin, INPUT_PULLUP);
uint32_t now = millis();
gStarted = true;
gStartedMs = now;
gLastCycleStartMs = 0;
gLastRawClosed = (digitalRead(kUsbDpPin) == LOW);
gStableClosed = gLastRawClosed;
gLastRawChangeMs = now;
if (gStableClosed) {
gLastCycleStartMs = now;
playCycleTick();
}
gNeedStaticRedraw = true;
gNeedRedraw = true;
}
static void toggleSettings() {
gSettingsOpen = !gSettingsOpen;
gNeedStaticRedraw = true;
gNeedRedraw = true;
resetCachedUiText();
}
static void handleStableContact(bool closed) {
uint32_t now = millis();
gStableClosed = closed;
if (closed) {
if (gLastCycleStartMs != 0) {
uint32_t cycleMs = now - gLastCycleStartMs;
if (cycleMs >= kPauseAfterMs) {
gShortStreak = 0;
gLastCycleStartMs = now;
playCycleTick();
} else if (cycleMs >= kMinCycleMs) {
addCycle(cycleMs);
gLastCycleStartMs = now;
playCycleTick();
alertIfNeeded();
}
} else {
gLastCycleStartMs = now;
playCycleTick();
}
}
gNeedRedraw = !gSettingsOpen;
}
static void pollContact() {
if (!gStarted) {
return;
}
bool rawClosed = (digitalRead(kUsbDpPin) == LOW);
uint32_t now = millis();
if (rawClosed != gLastRawClosed) {
gLastRawClosed = rawClosed;
gLastRawChangeMs = now;
}
if ((now - gLastRawChangeMs) >= kContactDebounceMs && gStableClosed != gLastRawClosed) {
handleStableContact(gLastRawClosed);
}
}
static void pollUserButton() {
bool down = digitalRead(PIN_USER_BTN) == LOW;
uint32_t now = millis();
if (down != gUserButtonDown && (now - gUserButtonChangeMs) >= kButtonDebounceMs) {
gUserButtonDown = down;
gUserButtonChangeMs = now;
if (down) {
toggleSettings();
}
}
}
static uint8_t sliderValueFromX(const Rect &rect, int16_t x, uint8_t maxValue) {
int16_t left = rect.x + 22;
int16_t right = rect.x + rect.w - 22;
if (x < left) x = left;
if (x > right) x = right;
return (uint8_t)(((uint32_t)(x - left) * maxValue + (right - left) / 2) / (right - left));
}
static void handleSettingsTouch(int16_t x, int16_t y) {
if (contains(kLimitSlider, x, y)) {
uint8_t next = sliderValueFromX(kLimitSlider, x, 4);
if (next == gLimitIndex) {
return;
}
gLimitIndex = next;
} else if (contains(kTickSlider, x, y)) {
uint8_t next = sliderValueFromX(kTickSlider, x, 10);
if (next == gTickVolume) {
return;
}
gTickVolume = next;
playCycleTick();
} else if (contains(kAlertSlider, x, y)) {
uint8_t next = sliderValueFromX(kAlertSlider, x, 10);
if (next == gAlertVolume) {
return;
}
gAlertVolume = next;
playAlertBeep();
} else {
return;
}
saveSettings();
gNeedRedraw = true;
}
static void pollTouch() {
int16_t x = 0;
int16_t y = 0;
bool touching = gTouch.getPoint(&x, &y, 1) > 0;
if (touching && !gTouchDown) {
gTouchDown = true;
gTouchStartX = x;
gTouchStartY = y;
gTouchLastX = x;
gTouchLastY = y;
return;
}
if (touching && gTouchDown) {
gTouchLastX = x;
gTouchLastY = y;
return;
}
if (!touching && gTouchDown) {
gTouchDown = false;
int dx = abs(gTouchLastX - gTouchStartX);
int dy = abs(gTouchLastY - gTouchStartY);
if (dx >= 14 || dy >= 14) {
return;
}
if (gSettingsOpen) {
handleSettingsTouch(gTouchLastX, gTouchLastY);
} else if (!gStarted && contains(kStartButton, gTouchLastX, gTouchLastY)) {
enterSensorMode();
}
}
}
void setup() {
Serial.begin(115200);
Wire.begin(PIN_I2C_SDA, PIN_I2C_SCL);
pinMode(PIN_USER_BTN, INPUT_PULLUP);
loadSettings();
initAudio();
gfx->begin();
gBus->writeC8D8(0x36, 0xA0);
gfx->setBrightness(220);
gfx->fillScreen(C_BG);
gTouch.setPins(PIN_TP_INT, -1);
bool touchOk = gTouch.begin(Wire, CST92XX_SLAVE_ADDRESS, PIN_I2C_SDA, PIN_I2C_SCL);
gTouch.setMaxCoordinates(DISP_W, DISP_H);
gTouch.setSwapXY(true);
gTouch.setMirrorXY(true, false);
Serial.println("Breath monitor ready.");
Serial.println(touchOk ? "Touch init OK" : "Touch init failed");
gNeedRedraw = true;
}
void loop() {
pollUserButton();
pollTouch();
pollContact();
if (gStarted && !gSettingsOpen && millis() - gLastUiMs >= kUiPeriodMs) {
updateMonitorValues(false);
gLastUiMs = millis();
}
if (gNeedRedraw) {
redrawScreen();
}
delay(10);
}
@@ -1,407 +0,0 @@
#include <Arduino.h>
#include <Wire.h>
#include <lvgl.h>
#include <Arduino_GFX_Library.h>
#include "pin_config.h"
#include "TouchDrvCSTXXX.hpp"
#define EXAMPLE_LVGL_TICK_PERIOD_MS 2
// ESP32-S3 native USB data pins.
static constexpr int kUsbDmPin = 19; // USB D-
static constexpr int kUsbDpPin = 20; // USB D+
static constexpr int kUserButtonPin = 0; // BOOT/user button, active LOW.
static constexpr uint32_t kDebounceMs = 20;
static constexpr uint32_t kEnterDelayMs = 250;
static constexpr uint32_t kButtonDebounceMs = 35;
static lv_disp_draw_buf_t gDrawBuf;
static lv_color_t *gBuf1 = nullptr;
static lv_color_t *gBuf2 = nullptr;
static lv_obj_t *gRawLabel = nullptr;
static lv_obj_t *gEventLabel = nullptr;
static lv_obj_t *gModeLabel = nullptr;
static lv_obj_t *gStateLabel = nullptr;
static lv_obj_t *gActionButton = nullptr;
static lv_obj_t *gActionButtonLabel = nullptr;
static lv_obj_t *gMarker = nullptr;
static TouchDrvCST92xx gTouch;
static int16_t gTouchX[5];
static int16_t gTouchY[5];
static volatile bool gTouchPressed = false;
static volatile int16_t gLastTouchX = -1;
static volatile int16_t gLastTouchY = -1;
static volatile uint32_t gRawTouchCount = 0;
static uint32_t gButtonPressCount = 0;
static uint32_t gButtonClickCount = 0;
static bool gLastButtonRawPressed = false;
static bool gButtonStablePressed = false;
static uint32_t gLastButtonRawChangeMs = 0;
static bool gSensorMode = false;
static bool gEnterPending = false;
static uint32_t gEnterAtMs = 0;
static bool gStableClosed = false;
static bool gLastRawClosed = false;
static uint32_t gLastRawChangeMs = 0;
static uint32_t gLastUiRefreshMs = 0;
Arduino_DataBus *gBus = new Arduino_ESP32QSPI(
LCD_CS, LCD_SCLK, LCD_SDIO0, LCD_SDIO1, LCD_SDIO2, LCD_SDIO3);
Arduino_CO5300 *gfx = new Arduino_CO5300(
gBus, LCD_RESET, 0, LCD_WIDTH, LCD_HEIGHT, 0, 0, 0, 0);
static void lvglFlushCb(lv_disp_drv_t *disp, const lv_area_t *area, lv_color_t *colorP) {
uint32_t w = area->x2 - area->x1 + 1;
uint32_t h = area->y2 - area->y1 + 1;
#if (LV_COLOR_16_SWAP != 0)
gfx->draw16bitBeRGBBitmap(area->x1, area->y1, (uint16_t *)&colorP->full, w, h);
#else
gfx->draw16bitRGBBitmap(area->x1, area->y1, (uint16_t *)&colorP->full, w, h);
#endif
lv_disp_flush_ready(disp);
}
static void lvglTick(void *arg) {
LV_UNUSED(arg);
lv_tick_inc(EXAMPLE_LVGL_TICK_PERIOD_MS);
}
static void lvglTouchRead(lv_indev_drv_t *indevDrv, lv_indev_data_t *data) {
LV_UNUSED(indevDrv);
uint8_t touched = gTouch.getPoint(gTouchX, gTouchY, gTouch.getSupportTouchPoint());
if (touched > 0) {
gTouchPressed = true;
gLastTouchX = gTouchX[0];
gLastTouchY = gTouchY[0];
gRawTouchCount++;
data->state = LV_INDEV_STATE_PR;
data->point.x = gTouchX[0];
data->point.y = gTouchY[0];
return;
}
gTouchPressed = false;
data->state = LV_INDEV_STATE_REL;
}
static void setStateUi(bool closed) {
if (closed) {
lv_label_set_text(gStateLabel, "CLOSED");
lv_obj_set_style_text_color(gStateLabel, lv_color_hex(0x6DFF8B), 0);
} else {
lv_label_set_text(gStateLabel, "OPEN");
lv_obj_set_style_text_color(gStateLabel, lv_color_hex(0xFFD166), 0);
}
}
static void updateTouchDiagnostics() {
uint32_t now = millis();
if (now - gLastUiRefreshMs < 40) return;
gLastUiRefreshMs = now;
String raw = gTouchPressed ? "RAW: PRESSED" : "RAW: released";
raw += "\nx=" + String((int)gLastTouchX) + " y=" + String((int)gLastTouchY);
raw += " n=" + String((uint32_t)gRawTouchCount);
lv_label_set_text(gRawLabel, raw.c_str());
if (gTouchPressed && gLastTouchX >= 0 && gLastTouchY >= 0) {
int markerX = gLastTouchX - 8;
int markerY = gLastTouchY - 8;
if (markerX < 0) markerX = 0;
if (markerY < 0) markerY = 0;
lv_obj_set_pos(gMarker, markerX, markerY);
lv_obj_clear_flag(gMarker, LV_OBJ_FLAG_HIDDEN);
} else {
lv_obj_add_flag(gMarker, LV_OBJ_FLAG_HIDDEN);
}
}
static void actuallyEnterSensorMode() {
gEnterPending = false;
// Make the visual transition happen BEFORE the USB data pins are repurposed.
lv_label_set_text(gModeLabel, "SENSOR MODE");
lv_label_set_text(gActionButtonLabel, "Restart to USB");
lv_obj_set_style_bg_color(gActionButton, lv_color_hex(0xA33D4F), LV_PART_MAIN | LV_STATE_DEFAULT);
lv_obj_set_style_bg_color(gActionButton, lv_color_hex(0xC94F65), LV_PART_MAIN | LV_STATE_PRESSED);
lv_label_set_text(gEventLabel, "GPIO19=D- LOW GPIO20=D+ INPUT_PULLUP");
lv_label_set_text(gStateLabel, "SWITCHING...");
lv_obj_set_style_text_color(gStateLabel, lv_color_hex(0x72D6FF), 0);
lv_refr_now(nullptr);
delay(60);
// Intentionally repurpose only USB D-/D+. These are not LCD or touch pins.
// Do NOT call Serial.flush() here: USB CDC may already be disappearing.
pinMode(kUsbDmPin, OUTPUT);
digitalWrite(kUsbDmPin, LOW);
pinMode(kUsbDpPin, INPUT_PULLUP);
gSensorMode = true;
gLastRawClosed = (digitalRead(kUsbDpPin) == LOW);
gStableClosed = gLastRawClosed;
gLastRawChangeMs = millis();
setStateUi(gStableClosed);
}
static void actionButtonEventCb(lv_event_t *event) {
lv_event_code_t code = lv_event_get_code(event);
if (code == LV_EVENT_PRESSED) {
gButtonPressCount++;
String text = "BUTTON PRESSED #" + String(gButtonPressCount);
lv_label_set_text(gEventLabel, text.c_str());
if (!gSensorMode && !gEnterPending) {
lv_label_set_text(gActionButtonLabel, "Starting...");
lv_label_set_text(gStateLabel, "TOUCH OK");
lv_obj_set_style_text_color(gStateLabel, lv_color_hex(0x7CFF8A), 0);
}
return;
}
if (code != LV_EVENT_CLICKED) return;
gButtonClickCount++;
if (!gSensorMode) {
lv_label_set_text(gModeLabel, "USB MODE");
lv_label_set_text(gActionButtonLabel, "TOUCH OK");
lv_label_set_text(gStateLabel, "PRESS BOOT");
lv_obj_set_style_text_color(gStateLabel, lv_color_hex(0xFFD166), 0);
String text = "TOUCH CLICK OK #" + String(gButtonClickCount) + " use BOOT button";
lv_label_set_text(gEventLabel, text.c_str());
lv_refr_now(nullptr);
return;
}
lv_label_set_text(gModeLabel, "RESTARTING TO USB...");
lv_label_set_text(gActionButtonLabel, "Restarting...");
lv_label_set_text(gStateLabel, "USB NEXT BOOT");
lv_refr_now(nullptr);
delay(180);
ESP.restart();
}
static void requestEnterSensorMode(const char *source) {
if (gSensorMode || gEnterPending) {
return;
}
gEnterPending = true;
gEnterAtMs = millis() + kEnterDelayMs;
lv_label_set_text(gModeLabel, "START RECEIVED");
lv_label_set_text(gActionButtonLabel, "Starting sensor...");
String text = String(source) + " OK waiting 250 ms";
lv_label_set_text(gEventLabel, text.c_str());
lv_label_set_text(gStateLabel, "STARTING...");
lv_obj_set_style_text_color(gStateLabel, lv_color_hex(0x7CFF8A), 0);
lv_refr_now(nullptr);
}
static void pollUserButton() {
bool rawPressed = (digitalRead(kUserButtonPin) == LOW);
uint32_t now = millis();
if (rawPressed != gLastButtonRawPressed) {
gLastButtonRawPressed = rawPressed;
gLastButtonRawChangeMs = now;
}
if ((now - gLastButtonRawChangeMs) < kButtonDebounceMs || rawPressed == gButtonStablePressed) {
return;
}
gButtonStablePressed = rawPressed;
if (!gButtonStablePressed) {
return;
}
gButtonClickCount++;
if (!gSensorMode) {
requestEnterSensorMode("BOOT BUTTON");
return;
}
lv_label_set_text(gModeLabel, "RESTARTING TO USB...");
lv_label_set_text(gActionButtonLabel, "Restarting...");
lv_label_set_text(gStateLabel, "USB NEXT BOOT");
lv_refr_now(nullptr);
delay(180);
ESP.restart();
}
static void createUi() {
lv_obj_t *screen = lv_scr_act();
lv_obj_set_style_bg_color(screen, lv_color_hex(0x000000), 0);
lv_obj_set_style_bg_opa(screen, LV_OPA_COVER, 0);
lv_obj_t *title = lv_label_create(screen);
lv_label_set_text(title, "USB CONTACT DEBUG");
lv_obj_set_style_text_font(title, &lv_font_montserrat_22, 0);
lv_obj_set_style_text_color(title, lv_color_hex(0xFFFFFF), 0);
lv_obj_align(title, LV_ALIGN_TOP_MID, 0, 10);
gRawLabel = lv_label_create(screen);
lv_label_set_text(gRawLabel, "RAW: released\nx=-1 y=-1 n=0");
lv_obj_set_style_text_font(gRawLabel, &lv_font_montserrat_16, 0);
lv_obj_set_style_text_color(gRawLabel, lv_color_hex(0x9EE493), 0);
lv_obj_align(gRawLabel, LV_ALIGN_TOP_LEFT, 14, 48);
gModeLabel = lv_label_create(screen);
lv_label_set_text(gModeLabel, "USB MODE");
lv_obj_set_style_text_font(gModeLabel, &lv_font_montserrat_18, 0);
lv_obj_set_style_text_color(gModeLabel, lv_color_hex(0x72D6FF), 0);
lv_obj_align(gModeLabel, LV_ALIGN_TOP_RIGHT, -14, 50);
gEventLabel = lv_label_create(screen);
lv_label_set_text(gEventLabel, "Button events: waiting");
lv_obj_set_width(gEventLabel, 440);
lv_label_set_long_mode(gEventLabel, LV_LABEL_LONG_WRAP);
lv_obj_set_style_text_align(gEventLabel, LV_TEXT_ALIGN_CENTER, 0);
lv_obj_set_style_text_font(gEventLabel, &lv_font_montserrat_16, 0);
lv_obj_set_style_text_color(gEventLabel, lv_color_hex(0xFFD166), 0);
lv_obj_align(gEventLabel, LV_ALIGN_TOP_MID, 0, 102);
gStateLabel = lv_label_create(screen);
lv_label_set_text(gStateLabel, "READY");
lv_obj_set_style_text_font(gStateLabel, &lv_font_montserrat_40, 0);
lv_obj_set_style_text_color(gStateLabel, lv_color_hex(0x72D6FF), 0);
lv_obj_align(gStateLabel, LV_ALIGN_CENTER, 0, -52);
// Put the button in almost the same position/size as the known-working touch debug sketch.
gActionButton = lv_btn_create(screen);
lv_obj_set_size(gActionButton, 360, 110);
lv_obj_align(gActionButton, LV_ALIGN_CENTER, 0, 52);
lv_obj_set_style_radius(gActionButton, 18, 0);
lv_obj_set_style_bg_color(gActionButton, lv_color_hex(0x2A9D8F), LV_PART_MAIN | LV_STATE_DEFAULT);
lv_obj_set_style_bg_color(gActionButton, lv_color_hex(0x47C7B6), LV_PART_MAIN | LV_STATE_PRESSED);
lv_obj_set_style_border_width(gActionButton, 3, 0);
lv_obj_set_style_border_color(gActionButton, lv_color_hex(0xBDE0FE), 0);
lv_obj_add_event_cb(gActionButton, actionButtonEventCb, LV_EVENT_ALL, nullptr);
gActionButtonLabel = lv_label_create(gActionButton);
lv_label_set_text(gActionButtonLabel, "START");
lv_obj_set_style_text_font(gActionButtonLabel, &lv_font_montserrat_28, 0);
lv_obj_set_style_text_color(gActionButtonLabel, lv_color_hex(0xFFFFFF), 0);
lv_obj_center(gActionButtonLabel);
lv_obj_t *hint = lv_label_create(screen);
lv_label_set_text(hint, "Press BOOT button to START. Touch button only checks touch UI.");
lv_obj_set_width(hint, 440);
lv_label_set_long_mode(hint, LV_LABEL_LONG_WRAP);
lv_obj_set_style_text_align(hint, LV_TEXT_ALIGN_CENTER, 0);
lv_obj_set_style_text_font(hint, &lv_font_montserrat_14, 0);
lv_obj_set_style_text_color(hint, lv_color_hex(0xD9D9D9), 0);
lv_obj_align(hint, LV_ALIGN_BOTTOM_MID, 0, -18);
gMarker = lv_obj_create(screen);
lv_obj_set_size(gMarker, 16, 16);
lv_obj_set_style_radius(gMarker, LV_RADIUS_CIRCLE, 0);
lv_obj_set_style_bg_color(gMarker, lv_color_hex(0xFF4D6D), 0);
lv_obj_set_style_border_width(gMarker, 2, 0);
lv_obj_set_style_border_color(gMarker, lv_color_hex(0xFFFFFF), 0);
lv_obj_add_flag(gMarker, LV_OBJ_FLAG_HIDDEN);
}
static void pollContact() {
if (!gSensorMode) return;
bool rawClosed = (digitalRead(kUsbDpPin) == LOW);
uint32_t now = millis();
if (rawClosed != gLastRawClosed) {
gLastRawClosed = rawClosed;
gLastRawChangeMs = now;
}
if ((now - gLastRawChangeMs) >= kDebounceMs && gStableClosed != gLastRawClosed) {
gStableClosed = gLastRawClosed;
setStateUi(gStableClosed);
}
}
void setup() {
Serial.begin(115200);
pinMode(kUserButtonPin, INPUT_PULLUP);
Wire.begin(IIC_SDA, IIC_SCL);
pinMode(TP_RST, OUTPUT);
pinMode(TP_INT, INPUT);
digitalWrite(TP_RST, LOW);
delay(30);
digitalWrite(TP_RST, HIGH);
delay(50);
delay(1000);
gTouch.setPins(TP_RST, TP_INT);
bool touchOk = gTouch.begin(Wire, 0x5A, IIC_SDA, IIC_SCL);
if (!touchOk) {
Serial.println("Touch init failed");
} else {
Serial.print("Touch model: ");
Serial.println(gTouch.getModelName());
gTouch.sleep();
gTouch.reset();
gTouch.setMaxCoordinates(480, 480);
gTouch.setSwapXY(true);
gTouch.setMirrorXY(true, false);
}
gfx->begin();
gBus->writeC8D8(0x36, 0xA0);
gfx->setBrightness(220);
gfx->fillScreen(0x0000);
lv_init();
uint32_t screenWidth = gfx->width();
uint32_t screenHeight = gfx->height();
gBuf1 = (lv_color_t *)heap_caps_malloc(screenWidth * screenHeight / 4 * sizeof(lv_color_t), MALLOC_CAP_DMA);
gBuf2 = (lv_color_t *)heap_caps_malloc(screenWidth * screenHeight / 4 * sizeof(lv_color_t), MALLOC_CAP_DMA);
lv_disp_draw_buf_init(&gDrawBuf, gBuf1, gBuf2, screenWidth * screenHeight / 4);
static lv_disp_drv_t dispDrv;
lv_disp_drv_init(&dispDrv);
dispDrv.hor_res = screenWidth;
dispDrv.ver_res = screenHeight;
dispDrv.flush_cb = lvglFlushCb;
dispDrv.draw_buf = &gDrawBuf;
lv_disp_drv_register(&dispDrv);
static lv_indev_drv_t indevDrv;
lv_indev_drv_init(&indevDrv);
indevDrv.type = LV_INDEV_TYPE_POINTER;
indevDrv.read_cb = lvglTouchRead;
lv_indev_drv_register(&indevDrv);
const esp_timer_create_args_t lvglTickTimerArgs = {
.callback = &lvglTick,
.name = "lvgl_tick"};
esp_timer_handle_t lvglTickTimer = nullptr;
esp_timer_create(&lvglTickTimerArgs, &lvglTickTimer);
esp_timer_start_periodic(lvglTickTimer, EXAMPLE_LVGL_TICK_PERIOD_MS * 1000);
createUi();
Serial.println("USB contact sensor DEBUG ready. USB pins remain untouched until START click.");
}
void loop() {
updateTouchDiagnostics();
pollUserButton();
pollContact();
if (gEnterPending && (int32_t)(millis() - gEnterAtMs) >= 0) {
actuallyEnterSensorMode();
}
lv_timer_handler();
delay(5);
}
@@ -1,250 +0,0 @@
#include <Arduino.h>
#include <Wire.h>
#include <lvgl.h>
#include <Arduino_GFX_Library.h>
#include "pin_config.h"
#include "TouchDrvCSTXXX.hpp"
#define EXAMPLE_LVGL_TICK_PERIOD_MS 2
// ESP32-S3 native USB pins.
static constexpr int kUsbDmPin = 19; // USB D-
static constexpr int kUsbDpPin = 20; // USB D+
static constexpr uint32_t kDebounceMs = 20;
static lv_disp_draw_buf_t gDrawBuf;
static lv_color_t *gBuf1 = nullptr;
static lv_color_t *gBuf2 = nullptr;
static lv_obj_t *gModeLabel = nullptr;
static lv_obj_t *gStateLabel = nullptr;
static lv_obj_t *gHintLabel = nullptr;
static lv_obj_t *gActionButton = nullptr;
static lv_obj_t *gActionButtonLabel = nullptr;
static TouchDrvCST92xx gTouch;
static int16_t gTouchX[5];
static int16_t gTouchY[5];
static bool gSensorMode = false;
static bool gStableClosed = false;
static bool gLastRawClosed = false;
static uint32_t gLastRawChangeMs = 0;
Arduino_DataBus *gBus = new Arduino_ESP32QSPI(
LCD_CS, LCD_SCLK, LCD_SDIO0, LCD_SDIO1, LCD_SDIO2, LCD_SDIO3);
Arduino_CO5300 *gfx = new Arduino_CO5300(
gBus, LCD_RESET, 0, LCD_WIDTH, LCD_HEIGHT, 0, 0, 0, 0);
static void lvglFlushCb(lv_disp_drv_t *disp, const lv_area_t *area, lv_color_t *colorP) {
uint32_t w = area->x2 - area->x1 + 1;
uint32_t h = area->y2 - area->y1 + 1;
#if (LV_COLOR_16_SWAP != 0)
gfx->draw16bitBeRGBBitmap(area->x1, area->y1, (uint16_t *)&colorP->full, w, h);
#else
gfx->draw16bitRGBBitmap(area->x1, area->y1, (uint16_t *)&colorP->full, w, h);
#endif
lv_disp_flush_ready(disp);
}
static void lvglTick(void *arg) {
LV_UNUSED(arg);
lv_tick_inc(EXAMPLE_LVGL_TICK_PERIOD_MS);
}
static void lvglTouchRead(lv_indev_drv_t *indevDrv, lv_indev_data_t *data) {
LV_UNUSED(indevDrv);
uint8_t touched = gTouch.getPoint(gTouchX, gTouchY, gTouch.getSupportTouchPoint());
if (touched > 0) {
data->state = LV_INDEV_STATE_PR;
data->point.x = gTouchX[0];
data->point.y = gTouchY[0];
return;
}
data->state = LV_INDEV_STATE_REL;
}
static void setStateUi(bool closed) {
if (closed) {
lv_label_set_text(gStateLabel, "CLOSED");
lv_obj_set_style_text_color(gStateLabel, lv_color_hex(0x7CFF8A), 0);
} else {
lv_label_set_text(gStateLabel, "OPEN");
lv_obj_set_style_text_color(gStateLabel, lv_color_hex(0xFFCC66), 0);
}
}
static void enterSensorMode() {
// From this moment the native USB data pair is no longer USB.
// D- is held LOW, D+ is read with the ESP32-S3 internal pull-up.
// A passive switch between D- and D+ therefore reads LOW when closed.
Serial.flush();
delay(30);
pinMode(kUsbDmPin, OUTPUT);
digitalWrite(kUsbDmPin, LOW);
pinMode(kUsbDpPin, INPUT_PULLUP);
gSensorMode = true;
gLastRawClosed = (digitalRead(kUsbDpPin) == LOW);
gStableClosed = gLastRawClosed;
gLastRawChangeMs = millis();
lv_label_set_text(gModeLabel, "Sensor mode");
lv_label_set_text(gHintLabel, "USB D- / D+ are now the contact input.\nDo not connect this port to a computer.");
lv_label_set_text(gActionButtonLabel, "Restart to USB");
setStateUi(gStableClosed);
}
static void actionButtonEventCb(lv_event_t *event) {
if (lv_event_get_code(event) != LV_EVENT_CLICKED) {
return;
}
if (!gSensorMode) {
enterSensorMode();
return;
}
lv_label_set_text(gModeLabel, "Restarting...");
lv_label_set_text(gHintLabel, "USB mode will return after reboot.");
lv_timer_handler();
delay(150);
ESP.restart();
}
static void createUi() {
lv_obj_t *screen = lv_scr_act();
lv_obj_set_style_bg_color(screen, lv_color_hex(0x0B1320), 0);
lv_obj_set_style_bg_opa(screen, LV_OPA_COVER, 0);
lv_obj_t *title = lv_label_create(screen);
lv_label_set_text(title, "USB CONTACT TEST");
lv_obj_set_style_text_color(title, lv_color_hex(0xFFFFFF), 0);
lv_obj_set_style_text_font(title, &lv_font_montserrat_22, 0);
lv_obj_align(title, LV_ALIGN_TOP_MID, 0, 26);
gModeLabel = lv_label_create(screen);
lv_label_set_text(gModeLabel, "USB mode");
lv_obj_set_style_text_color(gModeLabel, lv_color_hex(0xB8C8DC), 0);
lv_obj_set_style_text_font(gModeLabel, &lv_font_montserrat_18, 0);
lv_obj_align(gModeLabel, LV_ALIGN_TOP_MID, 0, 72);
gStateLabel = lv_label_create(screen);
lv_label_set_text(gStateLabel, "READY");
lv_obj_set_style_text_color(gStateLabel, lv_color_hex(0x72D6FF), 0);
lv_obj_set_style_text_font(gStateLabel, &lv_font_montserrat_40, 0);
lv_obj_align(gStateLabel, LV_ALIGN_CENTER, 0, -56);
gHintLabel = lv_label_create(screen);
lv_label_set_text(gHintLabel, "USB is normal now.\nTap Start to use D- / D+ as a contact sensor.");
lv_obj_set_width(gHintLabel, 390);
lv_label_set_long_mode(gHintLabel, LV_LABEL_LONG_WRAP);
lv_obj_set_style_text_align(gHintLabel, LV_TEXT_ALIGN_CENTER, 0);
lv_obj_set_style_text_color(gHintLabel, lv_color_hex(0xD5DCE5), 0);
lv_obj_set_style_text_font(gHintLabel, &lv_font_montserrat_16, 0);
lv_obj_align(gHintLabel, LV_ALIGN_CENTER, 0, 18);
gActionButton = lv_btn_create(screen);
lv_obj_set_size(gActionButton, 260, 72);
lv_obj_align(gActionButton, LV_ALIGN_BOTTOM_MID, 0, -48);
lv_obj_set_style_radius(gActionButton, 18, 0);
lv_obj_set_style_bg_color(gActionButton, lv_color_hex(0x2A9D8F), 0);
lv_obj_set_style_border_width(gActionButton, 0, 0);
lv_obj_add_event_cb(gActionButton, actionButtonEventCb, LV_EVENT_CLICKED, nullptr);
gActionButtonLabel = lv_label_create(gActionButton);
lv_label_set_text(gActionButtonLabel, "Start");
lv_obj_set_style_text_color(gActionButtonLabel, lv_color_hex(0xFFFFFF), 0);
lv_obj_set_style_text_font(gActionButtonLabel, &lv_font_montserrat_22, 0);
lv_obj_center(gActionButtonLabel);
}
static void pollContact() {
if (!gSensorMode) {
return;
}
bool rawClosed = (digitalRead(kUsbDpPin) == LOW);
uint32_t now = millis();
if (rawClosed != gLastRawClosed) {
gLastRawClosed = rawClosed;
gLastRawChangeMs = now;
}
if ((now - gLastRawChangeMs) >= kDebounceMs && gStableClosed != gLastRawClosed) {
gStableClosed = gLastRawClosed;
setStateUi(gStableClosed);
}
}
void setup() {
// With the project's FQBN this is the normal ESP32-S3 native USB serial mode.
// No sensor mode is persisted: every reset starts here with normal USB again.
Serial.begin(115200);
Wire.begin(IIC_SDA, IIC_SCL);
pinMode(TP_RST, OUTPUT);
pinMode(TP_INT, INPUT);
digitalWrite(TP_RST, LOW);
delay(30);
digitalWrite(TP_RST, HIGH);
delay(50);
delay(1000);
gTouch.setPins(TP_RST, TP_INT);
bool touchOk = gTouch.begin(Wire, 0x5A, IIC_SDA, IIC_SCL);
if (!touchOk) {
Serial.println("Touch init failed");
} else {
gTouch.sleep();
gTouch.reset();
gTouch.setMaxCoordinates(480, 480);
gTouch.setSwapXY(true);
gTouch.setMirrorXY(true, false);
}
gfx->begin();
gBus->writeC8D8(0x36, 0xA0);
gfx->setBrightness(220);
gfx->fillScreen(0x0000);
lv_init();
uint32_t screenWidth = gfx->width();
uint32_t screenHeight = gfx->height();
gBuf1 = (lv_color_t *)heap_caps_malloc(screenWidth * screenHeight / 4 * sizeof(lv_color_t), MALLOC_CAP_DMA);
gBuf2 = (lv_color_t *)heap_caps_malloc(screenWidth * screenHeight / 4 * sizeof(lv_color_t), MALLOC_CAP_DMA);
lv_disp_draw_buf_init(&gDrawBuf, gBuf1, gBuf2, screenWidth * screenHeight / 4);
static lv_disp_drv_t dispDrv;
lv_disp_drv_init(&dispDrv);
dispDrv.hor_res = screenWidth;
dispDrv.ver_res = screenHeight;
dispDrv.flush_cb = lvglFlushCb;
dispDrv.draw_buf = &gDrawBuf;
lv_disp_drv_register(&dispDrv);
static lv_indev_drv_t indevDrv;
lv_indev_drv_init(&indevDrv);
indevDrv.type = LV_INDEV_TYPE_POINTER;
indevDrv.read_cb = lvglTouchRead;
lv_indev_drv_register(&indevDrv);
const esp_timer_create_args_t lvglTickTimerArgs = {
.callback = &lvglTick,
.name = "lvgl_tick"};
esp_timer_handle_t lvglTickTimer = nullptr;
esp_timer_create(&lvglTickTimerArgs, &lvglTickTimer);
esp_timer_start_periodic(lvglTickTimer, EXAMPLE_LVGL_TICK_PERIOD_MS * 1000);
createUi();
Serial.println("USB contact sensor test ready; native USB remains active until Start is tapped.");
}
void loop() {
pollContact();
lv_timer_handler();
delay(5);
}
@@ -1,203 +0,0 @@
# USB contact sensor test
Diagnostic sketches:
- `main-device/test_sketches/usb_contact_sensor_test/usb_contact_sensor_test.ino`
- `main-device/test_sketches/usb_contact_sensor_debug_test/usb_contact_sensor_debug_test.ino`
- `main-device/test_sketches/breath_dual_mode_monitor/breath_dual_mode_monitor.ino`
- `main-device/test_sketches/usb_contact_resistance_test/usb_contact_resistance_test.ino`
- `main-device/test_sketches/usb_contact_screen_start_stub/usb_contact_screen_start_stub.ino`
## Purpose
Use the ESP32-S3 native USB data pair as a removable two-wire dry-contact input without making this mode persistent.
- `GPIO19` = native USB `D-`
- `GPIO20` = native USB `D+`
## Boot behavior
Every normal reset starts in ordinary native USB mode. The sketch does not save sensor mode in NVS or any other persistent storage.
Initial screen:
- title: `USB CONTACT TEST`
- mode: `USB mode`
- state: `READY`
- action button: `Start`
Until `Start` is pressed, the sketch does not reconfigure GPIO19/20.
## Sensor mode
After `Start`:
- GPIO19 is configured as `OUTPUT LOW`
- GPIO20 is configured as `INPUT_PULLUP`
- a passive switch/contact is connected between USB `D-` and `D+`
- open contact => GPIO20 reads HIGH => UI shows `OPEN`
- closed contact => GPIO20 reads LOW => UI shows `CLOSED`
- contact changes use a 20 ms debounce
Native USB data is intentionally unavailable while sensor mode owns GPIO19/20. The UI warns not to connect the port to a computer in this state.
The action button changes to `Restart to USB`. Pressing it calls `ESP.restart()`; after reboot normal USB mode is restored.
A physical reset/power cycle has the same effect. The ESP32-S3 ROM download mode remains available through the board's BOOT procedure if recovery is needed.
## Debug version
The debug sketch starts in normal USB mode and shows raw touch diagnostics on screen. The on-screen `START` button is intentionally diagnostic only: it confirms touch/LVGL button events and does not reconfigure GPIO19/20.
Sensor mode starts from the physical BOOT/user button on GPIO0, active LOW. The button is debounced for 35 ms, then the UI shows `START RECEIVED` / `STARTING...`, waits 250 ms so the visual transition is rendered, and only then reconfigures USB D-/D+ as the contact input.
While in sensor mode, pressing the BOOT/user button again restarts the device and returns normal USB mode on the next boot.
## Resistance version
The `usb_contact_resistance_test` sketch starts in normal USB mode and does not reconfigure GPIO19/20 until `Start` is tapped.
Initial screen:
- title: `USB RESISTANCE TEST`
- mode: `USB mode`
- state: `READY`
- action button: `Start`
After `Start`:
- GPIO19 / USB `D-` is configured as `OUTPUT HIGH`
- GPIO20 / USB `D+` is configured as ADC input
- the measured resistance is connected between `D-` and `D+`
- a known external 10 kΩ pulldown resistor must be connected from `D+` to `GND` for meaningful ohm calculation
- UI shows calculated resistance, raw ADC value, and measured `D+` millivolts
- very low ADC voltage is shown as `OPEN`
- near-source voltage is shown as `SHORT / LOW`
The calculation assumes a divider where the unknown resistance is the high-side resistor from 3.3 V to ADC and the known 10 kΩ resistor is the low-side resistor from ADC to GND:
`Rx = 10000 * (3300 / Vadc - 1)`
This test is intended to check whether the USB contact pair can be reused as an ADC-measured resistance input, for example before wiring a 10 kΩ potentiometer. Native USB data is unavailable while resistance mode owns GPIO19/20. Pressing `Restart to USB` calls `ESP.restart()`; after reboot normal USB mode is restored.
## GFX breath monitor version
The `usb_contact_screen_start_stub` sketch is a breath monitor firmware based on the production `Arduino_GFX` display path instead of LVGL.
Initial screen:
- title: `USB CONTACT`
- title in the current version: `BREATH MONITOR`
- state: `READY`
- action button: `START`
After tapping `START`:
- GPIO19 is configured as `OUTPUT LOW`
- GPIO20 is configured as `INPUT_PULLUP`
- closed contact is treated as `EXHALE`
- open contact is treated as `INHALE`
- one breathing cycle is measured from one stable `EXHALE` start to the next stable `EXHALE` start
- contact changes use an 80 ms debounce
- UI shows current cycle duration, arithmetic average duration over the last 5 completed cycles, and elapsed time from start
- the physical user/BOOT button opens and closes the settings screen
- settings screen has three touch sliders: limit `5/7/10/15/20` seconds, quiet cycle tick volume `0..10`, and alert volume `0..10`
- settings are persisted in NVS and restored after power off/on
- quiet cycle tick volume uses a compressed quiet scale: previous low audible levels are moved near `9..10`
- alert volume uses a gentler low range; level `5` equals the previous maximum alert level
- the working screen uses a static frame and only updates value regions to avoid display flicker
- the main screen header/status line and the bottom short-average streak line redraw only when their text changes
- the `START` button is a flat rounded rectangle with a border; there is no pause button in this version
- every new cycle start plays one quiet confirmation beep
- if the arithmetic average of the last up to 5 completed cycles is shorter than the selected limit, the device plays warning beeps: 1 beep for the first short average in a row, 2 beeps for the second, up to 5 beeps
- completed cycles shorter than 1.5 seconds are ignored as contact bounce
- if the current cycle exceeds 60 seconds, the main screen shows `PAUSE`; that long cycle is skipped and the next `EXHALE` start begins a fresh cycle from zero
- reset/power cycle restores ordinary native USB boot
This version is intended to monitor breathing cadence from a dry-contact USB D-/D+ sensor.
## Dual-mode GFX breath monitor version
The `breath_dual_mode_monitor` sketch reuses the production-style `Arduino_GFX` visual approach, audio path, settings sliders, and average-cycle alert behavior from the USB contact breath monitor. It supports two start modes on one firmware: USB contact sensor mode and external button mode.
Initial screen:
- title: `BREATH MONITOR`
- state: `READY`
- action button: `START USB SENSOR`
- action button: `START MANUAL MONITOR`
- action button: `START POT 3-WIRE`
- action button: `START POT 2-WIRE`
- action button: `START POT CAL`
- action button: `START PIN DIAG`
After `START USB SENSOR`:
- GPIO19 / USB `D-` is configured as `OUTPUT LOW`
- GPIO20 / USB `D+` is configured as `INPUT_PULLUP`
- closed contact is treated as `EXHALE`
- open contact is treated as `INHALE`
- USB sensor cycles shorter than 3 seconds are ignored without resetting the current cycle timer
- a short `KEY3 / GPIO18` press opens or closes settings in USB sensor mode
- the bottom line shows the durations of the last 5 accepted USB sensor cycles
After `START MANUAL MONITOR`:
- `KEY3 / GPIO18` is the external `INHALE` button, active LOW
- `BOOT / GPIO0` is the external `EXHALE` button, active LOW
- do not hold `BOOT` while booting or resetting the board
- the mode title is `MANUAL MONITOR`
- accepted manual phases strictly alternate: `INHALE`, then `EXHALE`; a repeated current button or `EXHALE` before the first `INHALE` is ignored without a beep or timer reset
- each accepted button press plays one quiet confirmation beep and starts a fresh `Phase time` timer for that inhale or exhale
- the working screen does not show touch `INHALE`/`EXHALE` buttons
- long-holding `KEY3 / INHALE` for about 850 ms opens settings; the long press still counts as an inhale press
- while settings are open, the next `KEY3 / INHALE` press closes settings and also counts as an inhale press
After `START POT 3-WIRE`:
- `GPIO19 / USB D-` is configured as `OUTPUT HIGH` and works as the 3.3 V side of the potentiometer test
- `GPIO20 / USB D+` is configured as ADC input and must be connected to the potentiometer wiper
- `USB GND` must be connected to the other edge pin of the potentiometer
- the screen shows position `0..100%`, a bar, ADC raw value, measured millivolts, and estimated `0..50 kΩ` resistance
- if ADC saturates or reaches an unsafe high-voltage threshold, the firmware releases `D-` and `D+` to `INPUT`, beeps, and shows `USB/PIN FAULT`
- this is only best-effort software protection; ESP32-S3 GPIO pins are not 5 V tolerant, so external wiring must still prevent 5 V from reaching `D+` or `D-`
After `START POT 2-WIRE`:
- `GPIO19 / USB D-` is configured as `OUTPUT HIGH`
- `GPIO20 / USB D+` is configured as ADC input with internal pulldown
- connect only two potentiometer pins between `D-` and `D+`: the wiper and one edge pin
- the screen shows rough position, raw ADC, millivolts, and rough estimated resistance
- this mode is intentionally approximate because the ESP32 internal pulldown value is not precise and can vary between boards
- use `START POT 3-WIRE` for stable and more linear future breath sensing
After `START POT CAL`:
- `GPIO19 / USB D-` is configured as `OUTPUT HIGH`
- `GPIO20 / USB D+` is configured as ADC input with internal pulldown
- connect only two potentiometer pins between `D-` and `D+`: the wiper and one edge pin
- the firmware tracks the observed minimum and maximum ADC millivolts
- the screen shows a calibrated `0..100%` position within the observed range, current millivolts, raw ADC, min-max range, and state
- `KEY3 / GPIO18` resets the learned min-max calibration
- this mode is for relative position testing on weak or shifted USB-pin ranges; it does not report real resistance
After `START PIN DIAG`:
- the firmware runs two alternating USB pin drive/read checks
- Test A drives `GPIO19 / USB D-` HIGH and reads `GPIO20 / USB D+` as ADC
- Test B drives `GPIO20 / USB D+` HIGH and reads `GPIO19 / USB D-` as ADC
- shorting `D-` and `D+` should make the ADC side rise if the pins are actually controllable as GPIO
- if both tests stay near 0 mV, the USB cable/host, USB PHY, or board wiring is likely holding the lines and the USB data pins are not usable as an analog sensor in that setup
In both modes:
- one breathing cycle is measured from one `EXHALE` tap to the next `EXHALE` tap
- inhale before any exhale does not create a cycle
- button-mode cycles shorter than 1.5 seconds are ignored
- USB sensor cycles shorter than 3 seconds are ignored
- the UI shows current cycle time, arithmetic average over the last 5 completed cycles, elapsed session time, selected limit, long-pause count, short-average count, and current short-average streak
- the lower numeric fields use a larger font than before
- if the average of the last up to 5 completed cycles is shorter than the selected limit, warning beeps are played like in the USB contact breath monitor
- if the current cycle reaches 60 seconds, 5 loud warning beeps are played, then after 5 seconds another 5 loud warning beeps are played, repeating until the user changes phase / exits the long cycle
- in manual monitor mode, a single loud warning beep is also played at 35, 40, 45, 50, and 55 seconds of an unchanged inhale or exhale; the repeated five-beep alarm starts at 60 seconds
- settings keep the same sliders: limit `5/7/10/15/20` seconds, quiet cycle tick volume `0..10`, and alert volume `0..10`
-86
View File
@@ -1,86 +0,0 @@
# Инструкция по commit и push в Git
## Репозиторий
Работать с Git нужно из корня репозитория `SHiNE-product/`:
```bash
cd /home/ai/work/SHiNE/SHiNE-server-sha256/SHiNE-product
```
## Канонический Gitea
Всегда использовать этот Git-сервер и этот remote:
```text
https://git.shineup.me/Aidar/SHiNE-server.git
```
Проверка и исправление `origin`:
```bash
git remote set-url origin https://git.shineup.me/Aidar/SHiNE-server.git
git remote -v
```
Старый адрес `git2.shineup.me` не использовать.
Секреты, токены, приватные ключи, `.env`, логи и сборочные артефакты в Git не добавлять.
## Перед коммитом
```bash
git status --short --branch
git diff --check
git diff
```
Перед обычным коммитом обновить `VERSION.properties`:
- только UI — увеличить `client.version`;
- только сервер — увеличить `server.version`;
- UI и сервер — увеличить обе версии;
- в рабочей ветке использовать patch-инкремент: `1.2.346` → `1.2.347`.
Сообщения коммитов писать на русском языке.
## Commit
```bash
git add <нужные-файлы>
git commit -m "Краткое описание изменения"
```
Для локального `git commit` токен не нужен. Не использовать `git add .`, если в рабочем дереве есть непроверенные локальные файлы.
## Push
Сначала проверить ветку и remote:
```bash
git branch --show-current
git remote -v
```
Для push использовать токен из переменной окружения `GITEA_TOKEN`; сам токен в команду, файл или историю shell не записывать. При HTTPS Git обычно запросит имя пользователя и пароль токена:
```bash
export GITEA_TOKEN='токен задаётся локально и не коммитится'
git push origin HEAD
unset GITEA_TOKEN
```
Если credential helper не умеет автоматически подставлять `GITEA_TOKEN`, использовать настроенный локально способ авторизации Gitea; не вставлять токен в URL remote.
После push проверить результат:
```bash
git status --short --branch
git log -1 --oneline
```
## Ветка `main`
`main` предназначена для стабильных версий. По умолчанию изменения сначала коммитить в рабочей ветке, затем вливать в `main`. Для merge в `main` увеличивать вторую цифру версии и обнулять третью: `1.2.346` → `1.3.0`.
Перед push в `main` отдельно проверить diff, версию и отсутствие секретов.
+3 -25
View File
@@ -1,29 +1,7 @@
# SHiNE
SHiNE — проект децентрализованного общения: браузерный клиент, сервер, пользовательские блокчейны, личные сообщения и интеграция с Solana и Arweave. Репозиторий содержит также экспериментальные компоненты для ESP32 и браузерное расширение кошелька.
## План запуска DAO
> **Статус:** активная разработка и подготовка к публичному запуску. Исходный код доступен для изучения; самостоятельный запуск возможен, но инструкции по установке ещё дорабатываются. Не все описанные в планах возможности реализованы.
План запуска DAO зафиксирован в [DAO_запуск/README.md](DAO_запуск/README.md).
## Как устроен проект
| Компонент | Назначение |
| --- | --- |
| [`shine-UI/`](shine-UI/) | Браузерный клиент и панель администратора сервера |
| [`SHiNE-server/`](SHiNE-server/) | WebSocket/HTTP сервер, PostgreSQL, блокчейн, доставка сообщений |
| [`shine-solana/shine/`](shine-solana/shine/) | Anchor-программы и инструменты Solana |
| [`SHiNE-browser-plugin-wallet/`](SHiNE-browser-plugin-wallet/) | Браузерное расширение кошелька |
| [`ESP32/`](ESP32/) | Прошивки и прототипы устройств |
| [`deploy/`](deploy/) | Скрипты и инструкции по развёртыванию |
Архитектура и границы компонентов описаны в [общей схеме](docs/ARCHITECTURE.md). Пользовательские блоки проектируются для публикации в Arweave; подробности и текущие ограничения тестового контура приведены в [документации блокчейна](docs/Blockchain/README.md).
## Самостоятельный запуск
Основной сервер собирается Gradle из корня репозитория. Для локального запуска предусмотрены `./gradlew startLocal` и `./gradlew startLocalWithBuild`; состав и требования этих задач зависят от локальной конфигурации. Начните с [инструкций по развёртыванию](deploy/README.md) и [примера настроек](application.properties.example). Клиент находится в `shine-UI/`. Публичное пошаговое руководство по установке всего комплекса ещё готовится.
## Документация
- [Каталог документации](docs/README.md) — действующие спецификации, инструкции и планы.
- [Общая архитектура](docs/ARCHITECTURE.md) — компоненты и потоки данных.
- [API](docs/API/09_Operations_Index.md), [формат блокчейна](docs/Blockchain/README.md), [личные сообщения](docs/Personal_Messages/README.md), [Solana](docs/Solana_Architecture/README.md).
- [Правила обновления документации](docs/CONTRIBUTING_DOCS.md).
Это рабочий список задач по `этап1` и `этап2`. Дальше ведём его как основной чек-лист запуска DAO и отмечаем в нём выполненные пункты по мере готовности.
@@ -52,84 +52,113 @@ function readStrU8(bytes, cursorRef) {
function parseServerFieldsFromUserPda(dataBytes) {
const bytes = dataBytes instanceof Uint8Array ? dataBytes : new Uint8Array(dataBytes || []);
if (bytes.length < 9) throw new Error('Некорректный формат PDA');
const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
if (bytes.length < 5) throw new Error('Некорректный формат PDA');
const cursorRef = { value: 0 };
const readU16 = () => { if (cursorRef.value + 2 > bytes.length) throw new Error('Повреждённый формат PDA'); const v = view.getUint16(cursorRef.value, true); cursorRef.value += 2; return v; };
const readU32 = () => { if (cursorRef.value + 4 > bytes.length) throw new Error('Повреждённый формат PDA'); const v = view.getUint32(cursorRef.value, true); cursorRef.value += 4; return v; };
const readU64 = () => { if (cursorRef.value + 8 > bytes.length) throw new Error('Повреждённый формат PDA'); const v = view.getBigUint64(cursorRef.value, true); cursorRef.value += 8; return v; };
const magic = new TextDecoder().decode(readBytes(bytes, cursorRef, 5));
if (magic !== 'SHiNE') throw new Error('Некорректный формат PDA');
const formatMajor = readU8(bytes, cursorRef);
const formatMinor = readU8(bytes, cursorRef);
if (formatMajor !== 1 || formatMinor !== 2) throw new Error(`Неподдерживаемый формат PDA ${formatMajor}.${formatMinor}`);
const recordLen = readU16();
if (recordLen < 73 || recordLen > bytes.length) throw new Error('Некорректный record_len PDA');
cursorRef.value += 1; // format_major
cursorRef.value += 1; // format_minor
cursorRef.value += 2; // record_len
cursorRef.value += 8; // created_at_ms
cursorRef.value += 8; // updated_at_ms
cursorRef.value += 4; // record_number
cursorRef.value += 32; // prev_record_hash
const login = readStrU8(bytes, cursorRef);
readStrU8(bytes, cursorRef); // login
const blocksCount = readU8(bytes, cursorRef);
let isServer = false;
let serverAddress = '';
let accessServers = [];
let recoveryKey32 = null;
let rootKey32 = null;
let clientKey32 = null;
let blockchainKey32 = null;
let forkCount = 0;
let blockchainName = '';
let homeserverSessions = [];
for (let i = 0; i < blocksCount; i += 1) {
const blockType = readU8(bytes, cursorRef);
const blockVersion = readU8(bytes, cursorRef);
if (blockVersion !== 0) throw new Error('Неподдерживаемая версия блока PDA');
if (blockType === 1 || blockType === 2) {
cursorRef.value += 1; // block_version
if (blockType === 0 || blockType === 1 || blockType === 2) {
const key32 = readBytes(bytes, cursorRef, 32);
if (blockType === 0) recoveryKey32 = key32;
if (blockType === 1) rootKey32 = key32;
else clientKey32 = key32;
if (blockType === 2) clientKey32 = key32;
continue;
}
const payloadLen = readU16();
const payloadEnd = cursorRef.value + payloadLen;
if (payloadEnd > recordLen - 64) throw new Error('Повреждённый variable block PDA');
if (blockType === 3) {
forkCount = readU16();
if (forkCount < 1) throw new Error('BlockchainRegistry пуст');
for (let j = 0; j < forkCount; j += 1) {
blockchainKey32 = readBytes(bytes, cursorRef, 32);
readU64(); // created_at_ms fork
readU32(); // paid_limit_bytes
const count = readU8(bytes, cursorRef);
for (let j = 0; j < count; j += 1) {
cursorRef.value += 1;
const currentBlockchainName = readStrU8(bytes, cursorRef);
const currentBlockchainKey32 = readBytes(bytes, cursorRef, 32);
if (!blockchainKey32) {
blockchainKey32 = currentBlockchainKey32;
blockchainName = currentBlockchainName;
}
cursorRef.value += 8 + 8 + 4 + 32 + 64;
const arPresent = readU8(bytes, cursorRef);
if (arPresent === 1) readStrU8(bytes, cursorRef);
}
} else if (blockType === 30) {
const addressCount = readU8(bytes, cursorRef);
if (addressCount !== 1) throw new Error('PDA 1.2 допускает ровно один адрес сервера');
readU8(bytes, cursorRef); // address_format_type
readU8(bytes, cursorRef); // address_format_version
serverAddress = readStrU8(bytes, cursorRef);
} else if (blockType === 40) {
continue;
}
if (blockType === 30) {
isServer = readU8(bytes, cursorRef) === 1;
if (isServer) {
cursorRef.value += 1; // address_format_type
cursorRef.value += 1; // address_format_version
serverAddress = readStrU8(bytes, cursorRef);
const syncCount = readU8(bytes, cursorRef);
for (let j = 0; j < syncCount; j += 1) readStrU8(bytes, cursorRef);
}
continue;
}
if (blockType === 40) {
const accessCount = readU8(bytes, cursorRef);
if (accessCount > 1) throw new Error('PDA 1.2 допускает максимум один access server');
accessServers = [];
for (let j = 0; j < accessCount; j += 1) accessServers.push(readStrU8(bytes, cursorRef));
continue;
}
cursorRef.value = payloadEnd;
if (blockType === 50) {
cursorRef.value += 1;
const sessionsCount = readU8(bytes, cursorRef);
for (let j = 0; j < sessionsCount; j += 1) {
const sessionType = readU8(bytes, cursorRef);
const sessionVersion = readU8(bytes, cursorRef);
const sessionName = readStrU8(bytes, cursorRef);
const sessionPubKey32 = readBytes(bytes, cursorRef, 32);
if (sessionType === 100) {
homeserverSessions.push({
sessionType,
sessionVersion,
sessionName,
sessionPubKeyBase58: new PublicKey(sessionPubKey32).toBase58(),
sessionPubKeyB64: `ed25519/${btoa(String.fromCharCode(...sessionPubKey32))}`,
});
}
}
continue;
}
if (blockType === 70) {
cursorRef.value += 1;
continue;
}
throw new Error(`Неизвестный блок PDA: ${blockType}`);
}
if (!rootKey32 || !clientKey32 || !blockchainKey32) throw new Error('PDA 1.2 не содержит обязательные ключи');
return {
isServer: Boolean(serverAddress),
isServer,
serverAddress: normalizeHostLike(serverAddress),
accessServers: accessServers.map((value) => normalizeServerLogin(value)).filter(Boolean),
publicKeys: {
recoveryKeyBase58: '',
rootKeyBase58: new PublicKey(rootKey32).toBase58(),
clientKeyBase58: new PublicKey(clientKey32).toBase58(),
blockchainKeyBase58: new PublicKey(blockchainKey32).toBase58(),
blockchainName: `${normalizeServerLogin(login)}-${String(forkCount).padStart(3, '0')}`,
recoveryKeyBase58: recoveryKey32 ? new PublicKey(recoveryKey32).toBase58() : '',
rootKeyBase58: rootKey32 ? new PublicKey(rootKey32).toBase58() : '',
clientKeyBase58: clientKey32 ? new PublicKey(clientKey32).toBase58() : '',
blockchainKeyBase58: blockchainKey32 ? new PublicKey(blockchainKey32).toBase58() : '',
blockchainName,
},
homeserverSessions: [],
homeserverSessions,
};
}
+1 -1
View File
@@ -7,7 +7,7 @@
"": {
"name": "shine-browser-plugin-wallet",
"version": "1.0.0",
"license": "UNLICENSED",
"license": "ISC",
"dependencies": {
"@noble/curves": "^1.5.0",
"@solana/web3.js": "^1.98.4"
+1 -2
View File
@@ -1,7 +1,6 @@
{
"name": "shine-browser-plugin-wallet",
"version": "1.0.0",
"private": true,
"description": "Chrome-compatible Manifest V3 plugin for SHiNE wallet-session login.",
"main": "popup.js",
"scripts": {
@@ -9,7 +8,7 @@
},
"keywords": [],
"author": "",
"license": "UNLICENSED",
"license": "ISC",
"dependencies": {
"@noble/curves": "^1.5.0",
"@solana/web3.js": "^1.98.4"
+13 -18
View File
@@ -15,25 +15,18 @@ SHiNE-server — серверная часть мессенджера SHiNE: Web
- `shine-server-config/` — конфигурация сервера
- `shine-server-log/` — логирование
- `shine-server-geo/` — геолокация IP
- `shine-server-solana-users-sync/` — синхронизация PDA Solana в серверные данные
- `shine-server-archive/` — публикация/импорт Arweave и workflow бесплатной регистрации
## Документация при изменении кода
- Новая или изменённая WS-операция: обновить профильный документ `../docs/API/` и `../docs/API/09_Operations_Index.md`; список зарегистрированных операций сверять с `JsonHandlerRegistry.java`.
- Формат блока, правила проверки или публикации: обновить `../docs/Blockchain/` и журнал изменений этого раздела.
- Доставка или формат DM: обновить затронутые документы из `../docs/Personal_Messages/README.md`.
- Синхронизация Solana users: обновить `../docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md` и `../deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md`.
- Регистрация с email, namespace или Arweave-сертификатами: обновить действующие документы в `../docs/registration-v2/`, а исторические планы явно оставлять помеченными как история.
- Изменение локального запуска или конфигурации: обновить корневой `../README.md`, `../docs/ARCHITECTURE.md` либо `../deploy/README.md` по затронутой теме.
## Настройка сервера в Solana (Solana PDA)
Серверный аккаунт SHiNE регистрируется как обычный `user_pda` формата 1.2 с присутствующим `ServerProfileBlock`. Отдельного `is_server` в PDA нет: наличие server profile означает, что аккаунт объявляет серверный endpoint.
Серверный аккаунт SHiNE регистрируется в Solana в виде `user_pda` с флагом `is_server=true`.
В PDA хранятся:
PDA 1.2 сейчас допускает **один** адрес сервера (`address_format_type + address_format_version + address`). Бинарный блок использует count/array, чтобы будущая версия протокола могла увеличить лимит без смены структуры блока. Прямой список `sync_servers` удалён: пользовательские blockchain синхронизируются через Arweave.
- **адрес сервера** (URL WebSocket/HTTPS, например `https://shineup.me/ws`);
- **список серверов синхронизации** (`sync_servers`) — логины SHiNE-аккаунтов серверов-партнёров,
с которыми синхронизируются блоки и DM;
- **корневой ключ** сервера (`root_key`).
Клиенты читают server PDA из Solana, получают опубликованный endpoint и подключаются к нему. Межсерверная доставка DM через access-server routing остаётся отдельным механизмом.
Клиенты читают PDA напрямую из Solana, чтобы узнать адрес сервера и при необходимости подключиться.
**Управление серверной PDA выполняется через Web-панель администратора:**
@@ -43,9 +36,10 @@ shine-UI/server-ui.html
Страницы:
- `shine-UI/server-ui/create-server-pda.html` — первичная регистрация серверного аккаунта;
- `shine-UI/server-ui/update-server-pda.html` — обновление адреса сервера.
- `shine-UI/server-ui/update-server-pda.html` — обновление адреса или списка sync_servers.
PDA 1.2 использует три постоянные роли ключей: `root` (cold recovery), `blockchain` (обычный authority и подпись блоков) и `client` (клиент/кошелёк). Обычный update авторизуется активным последним blockchain key; root используется для recovery и может менять root.
Для регистрации нужен полный keyBundle (root + device + blockchain).
Для обновления — только root + device (blockchain-ключ не нужен).
Актуальные адреса программ Solana (devnet):
- `shine_users`: `SHiNEPr1APdAgNBteUyBXcNovaHctpSjUu8oH2ZJdN6`
@@ -53,9 +47,10 @@ PDA 1.2 использует три постоянные роли ключей:
Подробнее: `docs/Инициализация_Solana_регистрации/README.md`
## Синхронизация пользовательских blockchain
## Синхронизация с партнёрскими серверами
Прямой peer-to-peer blockchain sync через `sync_servers` отключён. Сервер восстанавливает и синхронизирует пользовательские записи через Arweave. Код старого peer-sync пока может оставаться как inert legacy, но не должен включаться в runtime.
Сервер должен синхронизировать блоки блокчейна и DM с серверами-партнёрами из `sync_servers`.
Детали: `docs/Blockchain/sync-between-servers.md`
## Деплой
@@ -1,31 +0,0 @@
plugins {
id 'java'
}
group = 'shine'
version = '1.0.0'
java {
toolchain {
languageVersion = JavaLanguageVersion.of(17)
}
}
repositories { mavenCentral() }
dependencies {
implementation project(':shine-server-config')
implementation project(':shine-server-db')
implementation project(':shine-server-crypto')
implementation project(':shine-server-blockchain')
implementation project(':shine-server-net-protocol')
implementation project(':shine-server-solana-users-sync')
implementation 'com.fasterxml.jackson.core:jackson-databind:2.17.2'
implementation 'org.bouncycastle:bcprov-jdk18on:1.78.1'
implementation 'org.slf4j:slf4j-api:2.0.16'
testImplementation 'org.junit.jupiter:junit-jupiter:5.11.0'
}
test { useJUnitPlatform() }
@@ -1,103 +0,0 @@
package server.archive;
import blockchain.Ans104DataItem;
import java.io.ByteArrayOutputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/** Minimal ANS-104 binary bundle writer/reader. */
public final class Ans104Bundle {
public record Entry(byte[] id32, byte[] rawDataItem) {}
private Ans104Bundle() {}
public static byte[] write(List<byte[]> rawItems) {
if (rawItems == null || rawItems.isEmpty()) throw new IllegalArgumentException("ANS-104 bundle is empty");
if (rawItems.size() > 1_000_000) throw new IllegalArgumentException("Too many ANS-104 items");
List<Ans104DataItem> parsed = new ArrayList<>(rawItems.size());
long total = 32L + 64L * rawItems.size();
for (byte[] raw : rawItems) {
Ans104DataItem item = new Ans104DataItem(raw);
if (!item.verifySignature()) throw new IllegalArgumentException("Invalid ANS-104 DataItem signature");
parsed.add(item);
total = Math.addExact(total, raw.length);
}
if (total > Integer.MAX_VALUE) throw new IllegalArgumentException("Bundle too large for in-memory publisher: " + total);
ByteArrayOutputStream out = new ByteArrayOutputStream((int) total);
out.writeBytes(uint256LE(rawItems.size()));
for (int i = 0; i < rawItems.size(); i++) {
out.writeBytes(uint256LE(rawItems.get(i).length));
out.writeBytes(parsed.get(i).id32());
}
for (byte[] raw : rawItems) out.writeBytes(raw);
return out.toByteArray();
}
public static List<Entry> read(byte[] bundle, int maxItems) {
if (bundle == null || bundle.length < 32) throw new IllegalArgumentException("ANS-104 bundle too short");
long countLong = readUint256AsLong(bundle, 0);
if (countLong <= 0 || countLong > Math.max(1, maxItems)) {
throw new IllegalArgumentException("Bad ANS-104 bundle item count: " + countLong);
}
int count = (int) countLong;
long headerLong = 32L + 64L * count;
if (headerLong > bundle.length) throw new IllegalArgumentException("ANS-104 bundle header truncated");
int header = (int) headerLong;
long[] sizes = new long[count];
byte[][] ids = new byte[count][];
int hp = 32;
long payloadBytes = 0;
for (int i = 0; i < count; i++) {
sizes[i] = readUint256AsLong(bundle, hp); hp += 32;
ids[i] = Arrays.copyOfRange(bundle, hp, hp + 32); hp += 32;
if (sizes[i] <= 0 || sizes[i] > Integer.MAX_VALUE) throw new IllegalArgumentException("Bad DataItem size: " + sizes[i]);
payloadBytes = Math.addExact(payloadBytes, sizes[i]);
}
if (headerLong + payloadBytes != bundle.length) {
throw new IllegalArgumentException("ANS-104 bundle size mismatch: header=" + headerLong + " payload=" + payloadBytes + " actual=" + bundle.length);
}
List<Entry> out = new ArrayList<>(count);
int p = header;
for (int i = 0; i < count; i++) {
int len = (int) sizes[i];
byte[] raw = Arrays.copyOfRange(bundle, p, p + len);
p += len;
Ans104DataItem item = new Ans104DataItem(raw);
if (!Arrays.equals(ids[i], item.id32())) throw new IllegalArgumentException("Bundle entry ID mismatch at index " + i);
out.add(new Entry(ids[i], raw));
}
return out;
}
public static byte[] find(byte[] bundle, byte[] wantedId32, int maxItems) {
if (wantedId32 == null || wantedId32.length != 32) throw new IllegalArgumentException("wanted ID must be 32 bytes");
for (Entry e : read(bundle, maxItems)) {
if (Arrays.equals(e.id32(), wantedId32)) return e.rawDataItem();
}
return null;
}
/** ANS-104 bundle integers are 32-byte unsigned little-endian values. */
static byte[] uint256LE(long value) {
if (value < 0) throw new IllegalArgumentException("negative uint256");
byte[] out = new byte[32];
long v = value;
for (int i = 0; i < 8; i++) { out[i] = (byte) (v & 0xff); v >>>= 8; }
return out;
}
static long readUint256AsLong(byte[] data, int offset) {
if (offset < 0 || offset + 32 > data.length) throw new IllegalArgumentException("uint256 truncated");
for (int i = offset + 8; i < offset + 32; i++) {
if (data[i] != 0) throw new IllegalArgumentException("uint256 exceeds signed long range");
}
long v = 0;
for (int i = 7; i >= 0; i--) v = (v << 8) | (data[offset + i] & 0xffL);
if (v < 0) throw new IllegalArgumentException("uint256 exceeds signed long range");
return v;
}
}
@@ -1,142 +0,0 @@
package server.archive;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import server.sync.ArweavePublishSignal;
import java.util.Base64;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* Publisher с двумя путями доставки:
* 1) Turbo — немедленная неблокирующая попытка для только что принятого блока;
* 2) плановый fixed-delay цикл — страховочная добивка только зависших pending-записей.
*/
public final class ArweaveBlockPublisherScheduler {
private static final Logger log = LoggerFactory.getLogger(ArweaveBlockPublisherScheduler.class);
private static final long RETRY_MIN_PENDING_AGE_MS = 60_000L;
private static final AtomicBoolean STARTED = new AtomicBoolean(false);
private static final AtomicBoolean IMMEDIATE_DRAIN_SCHEDULED = new AtomicBoolean(false);
private static final ConcurrentLinkedQueue<ArweavePublishSignal.PendingRef> IMMEDIATE_QUEUE = new ConcurrentLinkedQueue<>();
private static final ConcurrentHashMap<String, Long> PENDING_SINCE_MS = new ConcurrentHashMap<>();
private static ScheduledExecutorService executor;
private static ArweaveBlockPublisherService service;
private static ArweaveBlocksConfig config;
private ArweaveBlockPublisherScheduler() {}
public static void startOrLog() {
ArweaveBlocksConfig cfg;
try { cfg = ArweaveBlocksConfig.load(); cfg.validatePublisher(); }
catch (Exception e) { log.error("Cannot read/validate Arweave block publisher config", e); return; }
if (!cfg.publishEnabled()) { log.info("Arweave user-block publisher disabled (mode=none)"); return; }
if (!STARTED.compareAndSet(false,true)) return;
try {
config = cfg;
service = new ArweaveBlockPublisherService(cfg);
executor = Executors.newSingleThreadScheduledExecutor(r -> {
Thread t = new Thread(r, "shine-arweave-block-publisher"); t.setDaemon(true); return t;
});
if (cfg.publishMode() == ArweaveBlocksConfig.PublishMode.TURBO) {
ArweavePublishSignal.setListener(ArweaveBlockPublisherScheduler::enqueueImmediateTurboPublish);
}
Runnable retryTask = () -> {
try {
if (config.publishMode() == ArweaveBlocksConfig.PublishMode.TURBO) {
long nowMs = System.currentTimeMillis();
service.runRetryCycle(
id -> isOldEnoughForRetry(id, nowMs),
id -> PENDING_SINCE_MS.remove(idKey(id))
);
} else {
service.runCycle();
}
} catch (Exception e) {
log.error("Arweave block publish retry cycle failed", e);
}
};
long retryInitialDelayMinutes = cfg.publishMode() == ArweaveBlocksConfig.PublishMode.TURBO
? cfg.publishIntervalMinutes()
: 0L;
executor.scheduleWithFixedDelay(retryTask, retryInitialDelayMinutes, cfg.publishIntervalMinutes(), TimeUnit.MINUTES);
log.info("Arweave user-block publisher enabled: mode={} immediateTurbo={} retryInterval={}m retryMinAge={}s",
cfg.publishMode(), cfg.publishMode() == ArweaveBlocksConfig.PublishMode.TURBO,
cfg.publishIntervalMinutes(), RETRY_MIN_PENDING_AGE_MS / 1000L);
} catch (Exception e) {
ArweavePublishSignal.clearListener();
STARTED.set(false);
log.error("Arweave user-block publisher failed to start", e);
}
}
private static void enqueueImmediateTurboPublish(ArweavePublishSignal.PendingRef item) {
if (!STARTED.get() || config == null || config.publishMode() != ArweaveBlocksConfig.PublishMode.TURBO) return;
PENDING_SINCE_MS.putIfAbsent(idKey(item.dataItemId()), System.currentTimeMillis());
IMMEDIATE_QUEUE.offer(item);
scheduleImmediateDrain();
}
private static boolean isOldEnoughForRetry(byte[] dataItemId, long nowMs) {
Long pendingSince = PENDING_SINCE_MS.get(idKey(dataItemId));
// Нет записи в памяти => pending пережил старт процесса и уже считается зависшим.
return pendingSince == null || nowMs - pendingSince >= RETRY_MIN_PENDING_AGE_MS;
}
private static String idKey(byte[] dataItemId) {
return Base64.getUrlEncoder().withoutPadding().encodeToString(dataItemId);
}
private static void scheduleImmediateDrain() {
ScheduledExecutorService currentExecutor = executor;
if (currentExecutor == null || currentExecutor.isShutdown()) return;
if (!IMMEDIATE_DRAIN_SCHEDULED.compareAndSet(false, true)) return;
try {
currentExecutor.execute(ArweaveBlockPublisherScheduler::drainImmediateQueue);
} catch (RuntimeException e) {
IMMEDIATE_DRAIN_SCHEDULED.set(false);
throw e;
}
}
private static void drainImmediateQueue() {
try {
ArweavePublishSignal.PendingRef item;
while ((item = IMMEDIATE_QUEUE.poll()) != null) {
try {
boolean resolved = service.publishAcceptedNow(item);
if (resolved) PENDING_SINCE_MS.remove(idKey(item.dataItemId()));
} catch (Exception e) {
// Turbo недоступен: не держим поток клиента и не молотим всю очередь одной и той же ошибкой.
// Все элементы уже надёжно лежат в БД с pending=TRUE; плановый цикл подберёт их после min-age.
log.warn("Immediate Turbo publish failed; pending blocks will be retried by the periodic cycle: {}", e.getMessage());
IMMEDIATE_QUEUE.clear();
break;
}
}
} finally {
IMMEDIATE_DRAIN_SCHEDULED.set(false);
if (!IMMEDIATE_QUEUE.isEmpty()) scheduleImmediateDrain();
}
}
public static void close() {
ArweavePublishSignal.clearListener();
IMMEDIATE_QUEUE.clear();
PENDING_SINCE_MS.clear();
IMMEDIATE_DRAIN_SCHEDULED.set(false);
ScheduledExecutorService e = executor;
executor = null;
service = null;
config = null;
STARTED.set(false);
if (e != null) e.shutdownNow();
}
}
@@ -1,221 +0,0 @@
package server.archive;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import shine.db.dao.BlocksDAO;
import shine.db.dao.KeyRotationCandidateBlocksDAO;
import shine.db.entities.BlockEntry;
import shine.db.entities.KeyRotationCandidateBlockEntry;
import server.sync.ArweavePublishSignal;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
/** Publishes locally-created signed user DataItems through the configured transport. */
public final class ArweaveBlockPublisherService {
private static final Logger log = LoggerFactory.getLogger(ArweaveBlockPublisherService.class);
private final ArweaveBlocksConfig cfg;
private final BlocksDAO blocksDAO = BlocksDAO.getInstance();
private final KeyRotationCandidateBlocksDAO candidateBlocksDAO = KeyRotationCandidateBlocksDAO.getInstance();
private final ArweaveL1Uploader arweaveUploader;
private final TurboDataItemUploader turboUploader;
public ArweaveBlockPublisherService(ArweaveBlocksConfig cfg) {
this.cfg = cfg;
this.arweaveUploader = cfg.publishMode() == ArweaveBlocksConfig.PublishMode.ARWEAVE ? new ArweaveL1Uploader(cfg) : null;
this.turboUploader = cfg.publishMode() == ArweaveBlocksConfig.PublishMode.TURBO ? new TurboDataItemUploader(cfg) : null;
}
/**
* Мгновенная попытка для только что принятого DataItem. Вызывается только из фонового executor-а:
* сетевой запрос AddBlock не ждёт результат Turbo. Если запись уже успел обработать другой цикл, это no-op.
* При ошибке pending-флаг в БД не меняется, поэтому обычный runCycle() повторит публикацию позже.
*/
public boolean publishAcceptedNow(ArweavePublishSignal.PendingRef pending) throws Exception {
if (cfg.publishMode() != ArweaveBlocksConfig.PublishMode.TURBO) return false;
byte[] id = pending.dataItemId();
if (pending.kind() == ArweavePublishSignal.Kind.KEY_ROTATION_CANDIDATE) {
KeyRotationCandidateBlockEntry entry = candidateBlocksDAO.getPendingArweaveByDataItemId(id);
if (entry == null) return true;
byte[] raw = entry.getBlockBytes();
if (raw == null || raw.length == 0) return false;
TurboDataItemUploader.UploadResult result = turboUploader.upload(raw, id);
candidateBlocksDAO.markArweavePublished(List.of(id), System.currentTimeMillis());
log.debug("Turbo immediately published key-rotation DataItem {} chain={} block={}",
result.dataItemId(), entry.getCandidateBlockchainName(), entry.getBlockNumber());
return true;
}
BlockEntry entry = blocksDAO.getPendingArweaveByDataItemId(id);
if (entry == null) return true;
byte[] raw = entry.getBlockBytes();
if (raw == null || raw.length == 0) return false;
TurboDataItemUploader.UploadResult result = turboUploader.upload(raw, id);
blocksDAO.markArweavePublished(List.of(id), System.currentTimeMillis());
log.debug("Turbo immediately published SHiNE DataItem {} chain={} block={}",
result.dataItemId(), entry.getBchName(), entry.getBlockNumber());
return true;
}
public int runCycle() throws Exception {
return runCycle(id -> true, id -> {});
}
/** Плановый retry может отфильтровать слишком свежие pending-записи и получить callback успешных id. */
public int runRetryCycle(Predicate<byte[]> eligible, Consumer<byte[]> onPublished) throws Exception {
return runCycle(eligible == null ? id -> true : eligible, onPublished == null ? id -> {} : onPublished);
}
private int runCycle(Predicate<byte[]> eligible, Consumer<byte[]> onPublished) throws Exception {
if (cfg.publishMode() == ArweaveBlocksConfig.PublishMode.NONE) return 0;
int maxItems = cfg.publishMaxItems();
int attempted = 0;
int published = 0;
// Ротация приоритетна: пользователь уже заблокирован для обычной записи и ждёт завершения копирования.
List<KeyRotationCandidateBlockEntry> rotationCandidates = candidateBlocksDAO.listPendingArweave(maxItems);
rotationCandidates = rotationCandidates.stream().filter(e -> eligible.test(e.getDataItemId())).toList();
if (!rotationCandidates.isEmpty()) {
attempted += rotationCandidates.size();
published += switch (cfg.publishMode()) {
case TURBO -> publishTurboRotation(rotationCandidates, onPublished);
case ARWEAVE -> publishDirectArweaveRotation(rotationCandidates);
case NONE -> 0;
};
}
int remaining = Math.max(0, maxItems - attempted);
if (remaining == 0) return published;
List<BlockEntry> candidates = blocksDAO.listPendingArweave(remaining);
candidates = candidates.stream().filter(e -> eligible.test(e.getDataItemId())).toList();
if (candidates.isEmpty()) return published;
published += switch (cfg.publishMode()) {
case TURBO -> publishTurbo(candidates, onPublished);
case ARWEAVE -> publishDirectArweave(candidates);
case NONE -> 0;
};
return published;
}
private int publishTurboRotation(List<KeyRotationCandidateBlockEntry> candidates, Consumer<byte[]> onPublished) throws Exception {
int published = 0;
Exception firstFailure = null;
for (KeyRotationCandidateBlockEntry e : candidates) {
byte[] raw = e.getBlockBytes();
byte[] id = e.getDataItemId();
if (raw == null || raw.length == 0 || id == null || id.length != 32) continue;
try {
TurboDataItemUploader.UploadResult result = turboUploader.upload(raw, id);
candidateBlocksDAO.markArweavePublished(List.of(id), System.currentTimeMillis());
onPublished.accept(id);
published++;
log.debug("Turbo published key-rotation DataItem {} chain={} block={}",
result.dataItemId(), e.getCandidateBlockchainName(), e.getBlockNumber());
} catch (Exception ex) {
if (firstFailure == null) firstFailure = ex;
log.warn("Turbo key-rotation publish failed: chain={} block={} bytes={} error={}",
e.getCandidateBlockchainName(), e.getBlockNumber(), raw.length, ex.getMessage());
}
}
if (published > 0) log.info("Published {} SHiNE key-rotation DataItems through Turbo", published);
if (published == 0 && firstFailure != null) throw firstFailure;
return published;
}
private int publishTurbo(List<BlockEntry> candidates, Consumer<byte[]> onPublished) throws Exception {
int published = 0;
Exception firstFailure = null;
for (BlockEntry e : candidates) {
byte[] raw = e.getBlockBytes();
byte[] id = e.getDataItemId();
if (raw == null || raw.length == 0 || id == null || id.length != 32) continue;
try {
TurboDataItemUploader.UploadResult result = turboUploader.upload(raw, id);
blocksDAO.markArweavePublished(List.of(id), System.currentTimeMillis());
onPublished.accept(id);
published++;
log.debug("Turbo published SHiNE DataItem {} chain={} block={}", result.dataItemId(), e.getBchName(), e.getBlockNumber());
} catch (Exception ex) {
if (firstFailure == null) firstFailure = ex;
log.warn("Turbo publish failed: chain={} block={} bytes={} error={}",
e.getBchName(), e.getBlockNumber(), raw.length, ex.getMessage());
}
}
if (published > 0) log.info("Published {} SHiNE test DataItems through Turbo", published);
if (published == 0 && firstFailure != null) throw firstFailure;
return published;
}
private int publishDirectArweaveRotation(List<KeyRotationCandidateBlockEntry> candidates) throws Exception {
List<byte[]> items = new ArrayList<>();
List<byte[]> ids = new ArrayList<>();
long estimated = 32;
for (KeyRotationCandidateBlockEntry e : candidates) {
byte[] raw = e.getBlockBytes();
byte[] id = e.getDataItemId();
if (raw == null || raw.length == 0 || id == null || id.length != 32) continue;
long next = estimated + 64L + raw.length;
if (!items.isEmpty() && next > cfg.publishMaxBundleBytes()) break;
if (next > cfg.publishMaxBundleBytes()) {
log.error("One key-rotation DataItem exceeds arweave.blocks.publish.maxBundleBytes: chain={} block={} bytes={}",
e.getCandidateBlockchainName(), e.getBlockNumber(), raw.length);
continue;
}
items.add(raw);
ids.add(id);
estimated = next;
}
if (items.isEmpty()) return 0;
byte[] bundle = Ans104Bundle.write(items);
List<ArweaveL1Uploader.Tag> rootTags = List.of(
new ArweaveL1Uploader.Tag("Content-Type", "application/octet-stream"),
new ArweaveL1Uploader.Tag("Bundle-Format", "binary"),
new ArweaveL1Uploader.Tag("Bundle-Version", "2.0.0")
);
ArweaveL1Uploader.UploadResult result = arweaveUploader.upload(bundle, rootTags);
candidateBlocksDAO.markArweavePublished(ids, System.currentTimeMillis());
log.info("Published {} SHiNE key-rotation DataItems in direct Arweave root tx {} (bundle={} bytes)",
items.size(), result.txId(), bundle.length);
return items.size();
}
private int publishDirectArweave(List<BlockEntry> candidates) throws Exception {
List<byte[]> items = new ArrayList<>();
List<byte[]> ids = new ArrayList<>();
long estimated = 32;
for (BlockEntry e : candidates) {
byte[] raw = e.getBlockBytes();
byte[] id = e.getDataItemId();
if (raw == null || raw.length == 0 || id == null || id.length != 32) continue;
long next = estimated + 64L + raw.length;
if (!items.isEmpty() && next > cfg.publishMaxBundleBytes()) break;
if (next > cfg.publishMaxBundleBytes()) {
log.error("One DataItem exceeds arweave.blocks.publish.maxBundleBytes: chain={} block={} bytes={}",
e.getBchName(), e.getBlockNumber(), raw.length);
continue;
}
items.add(raw);
ids.add(id);
estimated = next;
}
if (items.isEmpty()) return 0;
byte[] bundle = Ans104Bundle.write(items);
List<ArweaveL1Uploader.Tag> rootTags = List.of(
new ArweaveL1Uploader.Tag("Content-Type", "application/octet-stream"),
new ArweaveL1Uploader.Tag("Bundle-Format", "binary"),
new ArweaveL1Uploader.Tag("Bundle-Version", "2.0.0")
);
ArweaveL1Uploader.UploadResult result = arweaveUploader.upload(bundle, rootTags);
blocksDAO.markArweavePublished(ids, System.currentTimeMillis());
log.info("Published {} SHiNE test DataItems in direct Arweave root tx {} (bundle={} bytes)",
items.size(), result.txId(), bundle.length);
return items.size();
}
}
@@ -1,36 +0,0 @@
package server.archive;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
public final class ArweaveBlockSyncScheduler {
private static final Logger log = LoggerFactory.getLogger(ArweaveBlockSyncScheduler.class);
private static final AtomicBoolean STARTED = new AtomicBoolean(false);
private static ScheduledExecutorService executor;
private ArweaveBlockSyncScheduler() {}
public static void startOrLog() {
ArweaveBlocksConfig cfg;
try { cfg = ArweaveBlocksConfig.load(); }
catch (Exception e) { log.error("Cannot read Arweave block sync config", e); return; }
if (!cfg.syncEnabled()) { log.info("Arweave user-block sync disabled"); return; }
if (!STARTED.compareAndSet(false,true)) return;
try {
ArweaveBlockSyncService service = new ArweaveBlockSyncService(cfg);
// Один поток намеренно сериализует полный discovery и быстрые retry уже найденных DataItem.
executor = Executors.newSingleThreadScheduledExecutor(r -> { Thread t=new Thread(r,"shine-arweave-block-sync");t.setDaemon(true);return t; });
Runnable task=()->{try{service.runCycle();}catch(Exception e){log.error("Arweave block sync cycle failed",e);}};
Runnable retryTask=()->{try{service.runRetryCycle();}catch(Exception e){log.error("Arweave block fast retry failed",e);}};
executor.scheduleWithFixedDelay(task,0,cfg.syncIntervalMinutes(),TimeUnit.MINUTES);
executor.scheduleWithFixedDelay(retryTask,cfg.syncLocationRetrySeconds(),cfg.syncLocationRetrySeconds(),TimeUnit.SECONDS);
log.info("Arweave user-block sync enabled: interval={}m locationRetry={}s gateway={} turboApi={}",
cfg.syncIntervalMinutes(),cfg.syncLocationRetrySeconds(),cfg.syncGateway(),cfg.syncTurboApiBase());
} catch (Exception e) { STARTED.set(false); log.error("Arweave user-block sync failed to start",e); }
}
public static void close(){ScheduledExecutorService e=executor;if(e!=null)e.shutdownNow();}
}
@@ -1,791 +0,0 @@
package server.archive;
import blockchain.Ans104DataItem;
import blockchain.BchBlockEntry;
import server.archive.registration.VerifiedFreeRegistrationImporter;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import server.logic.ws_protocol.JSON.handlers.blockchain.Net_AddBlock_Handler;
import server.sync.BlockchainResyncGuard;
import shine.db.DbController;
import utils.config.AppConfig;
import shine.db.dao.ArweaveBlockImportDAO;
import shine.db.dao.BlockchainStateDAO;
import shine.db.dao.BlocksDAO;
import shine.db.dao.BlockchainForkSegmentsDAO;
import shine.db.dao.CanonicalChainResolver;
import shine.db.dao.ChannelReadStateDAO;
import shine.db.dao.BlockchainResyncCleanupDAO;
import shine.db.dao.SolanaUserPdaCurrentDAO;
import shine.db.entities.BlockchainStateEntry;
import shine.db.entities.SolanaUserPdaCurrentEntry;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.time.Duration;
import java.util.*;
/**
* Discovers individual App=test5592 DataItems and imports the exact signed ANS-104 bytes.
* The importer is transport-agnostic: a DataItem may have reached Arweave through Turbo
* or inside a direct server-created ANS-104 bundle.
*/
public final class ArweaveBlockSyncService {
private static final Logger log = LoggerFactory.getLogger(ArweaveBlockSyncService.class);
private static final ObjectMapper MAPPER = new ObjectMapper();
private static final Base64.Decoder B64URL = Base64.getUrlDecoder();
private final ArweaveBlocksConfig cfg;
private final HttpClient http = HttpClient.newBuilder()
.connectTimeout(Duration.ofSeconds(20))
.followRedirects(HttpClient.Redirect.NORMAL)
.build();
private final VerifiedFreeRegistrationImporter registrationImporter = new VerifiedFreeRegistrationImporter(
AppConfig.getInstance().getBoolean("freeRegistration.email.allowReuse", false));
private final ArweaveBlockImportDAO importDAO = ArweaveBlockImportDAO.getInstance();
private final BlocksDAO blocksDAO = BlocksDAO.getInstance();
private final SolanaUserPdaCurrentDAO usersDAO = SolanaUserPdaCurrentDAO.getInstance();
private final BlockchainStateDAO stateDAO = BlockchainStateDAO.getInstance();
private final Net_AddBlock_Handler addBlock = new Net_AddBlock_Handler();
private final BlockchainForkSegmentsDAO segmentsDAO = BlockchainForkSegmentsDAO.getInstance();
private final CanonicalChainResolver canonical = CanonicalChainResolver.getInstance();
private final BlockchainResyncCleanupDAO cleanupDAO = BlockchainResyncCleanupDAO.getInstance();
// DataItem уже виден через GraphQL, но его физические координаты внутри ANS-104 bundle
// ещё не появились у индексатора. Полный discovery остаётся редким, а эти ID ретраятся часто.
private final Map<String, PendingDownload> unresolvedDownloads = new LinkedHashMap<>();
public ArweaveBlockSyncService(ArweaveBlocksConfig cfg) { this.cfg = cfg; }
public void runCycle() throws Exception {
recoverInterruptedCanonicalRebuilds();
discover();
discoverFreeRegistrations();
drainQueue();
}
/** Быстрый retry только для уже обнаруженных DataItem, без повторного полного GraphQL discovery. */
public void runRetryCycle() throws Exception {
int queued = retryPendingDownloads();
if (queued > 0) drainQueue();
}
private void discover() throws Exception {
long stored = importDAO.getLastBlockHeight();
long minHeight = Math.max(cfg.syncStartBlockHeight(), stored);
String cursor = null;
long maxHeight = minHeight;
long lowestRetryHeight = Long.MAX_VALUE;
int discovered = 0;
do {
JsonNode response = graphQlPage(minHeight, cursor);
JsonNode txs = response.path("data").path("transactions");
if (response.has("errors")) throw new IOException("Arweave GraphQL errors: " + response.path("errors"));
JsonNode edges = txs.path("edges");
if (!edges.isArray()) throw new IOException("Arweave GraphQL returned no transactions.edges");
String nextCursor = null;
for (JsonNode edge : edges) {
nextCursor = edge.path("cursor").asText(null);
JsonNode node = edge.path("node");
String dataItemId = node.path("id").asText("").trim();
long height = node.path("block").path("height").asLong(-1L);
if (dataItemId.isBlank() || height < 0) continue;
maxHeight = Math.max(maxHeight, height);
byte[] id32;
try {
id32 = B64URL.decode(dataItemId);
if (id32.length != 32) throw new IllegalArgumentException("id length=" + id32.length);
} catch (Exception e) {
log.warn("Ignoring malformed Arweave DataItem id {}: {}", dataItemId, e.getMessage());
continue;
}
if (blocksDAO.existsByDataItemId(id32) || importDAO.exists(id32)) {
unresolvedDownloads.remove(dataItemId);
continue;
}
try {
DownloadedDataItem downloaded = downloadSignedDataItem(dataItemId);
if (isRegistrationItem(downloaded.rawDataItem())) {
registrationImporter.importSigned(downloaded.rawDataItem(),
VerifiedFreeRegistrationImporter.Provenance.ARWEAVE_CONFIRMED);
unresolvedDownloads.remove(dataItemId);
continue; // Не парсить регистрацию как BchBlockEntry.
}
unresolvedDownloads.remove(dataItemId);
if (importDAO.enqueueIfMissing(id32, downloaded.rootTxId(), height, downloaded.rawDataItem(), System.currentTimeMillis())) discovered++;
} catch (RetryableDataItemDownloadException e) {
lowestRetryHeight = Math.min(lowestRetryHeight, height);
unresolvedDownloads.put(dataItemId, new PendingDownload(dataItemId, id32, height));
log.info("Signed DataItem {} visible at height {} but raw ANS-104 bytes are not ready yet; queued for fast retry: {}",
dataItemId, height, e.getMessage());
} catch (Exception e) {
lowestRetryHeight = Math.min(lowestRetryHeight, height);
log.warn("Cannot retrieve signed DataItem {} at height {} yet: {}", dataItemId, height, e.getMessage());
}
}
boolean hasNext = txs.path("pageInfo").path("hasNextPage").asBoolean(false);
cursor = hasNext ? nextCursor : null;
if (hasNext && (cursor == null || cursor.isBlank())) throw new IOException("GraphQL hasNextPage without cursor");
} while (cursor != null);
// Keep inclusive overlap. If a gateway has indexed GraphQL before offsets, do not advance past that item.
long checkpoint = lowestRetryHeight == Long.MAX_VALUE ? maxHeight : Math.min(maxHeight, lowestRetryHeight);
importDAO.setLastBlockHeight(checkpoint, System.currentTimeMillis());
if (discovered > 0) {
log.info("Arweave discovery queued {} new SHiNE test DataItems; checkpoint={}", discovered, checkpoint);
}
}
private int retryPendingDownloads() throws Exception {
if (unresolvedDownloads.isEmpty()) return 0;
int queued = 0;
int attempted = 0;
List<PendingDownload> snapshot = new ArrayList<>(unresolvedDownloads.values());
for (PendingDownload pending : snapshot) {
if (attempted >= cfg.syncPageSize()) break;
attempted++;
if (blocksDAO.existsByDataItemId(pending.id32()) || importDAO.exists(pending.id32())) {
unresolvedDownloads.remove(pending.dataItemId());
continue;
}
DownloadedDataItem downloaded;
try {
downloaded = downloadSignedDataItem(pending.dataItemId());
} catch (RetryableDataItemDownloadException e) {
// Переносим в конец LinkedHashMap, чтобы первые 100 зависших ID не блокировали retry следующих.
unresolvedDownloads.remove(pending.dataItemId());
unresolvedDownloads.put(pending.dataItemId(), pending);
log.debug("ANS-104 DataItem {} still waits for location/raw bytes: {}", pending.dataItemId(), e.getMessage());
continue;
} catch (Exception e) {
// Не долбим явно плохой ответ каждые 30 секунд. Полный discovery попробует его снова позднее.
unresolvedDownloads.remove(pending.dataItemId());
log.warn("Fast retry stopped for signed DataItem {} until next discovery: {}", pending.dataItemId(), e.getMessage());
continue;
}
if (isRegistrationItem(downloaded.rawDataItem())) {
try {
registrationImporter.importSigned(downloaded.rawDataItem(),
VerifiedFreeRegistrationImporter.Provenance.ARWEAVE_CONFIRMED);
unresolvedDownloads.remove(pending.dataItemId());
} catch (Exception e) {
unresolvedDownloads.remove(pending.dataItemId());
unresolvedDownloads.put(pending.dataItemId(), pending);
log.debug("Registration {} awaits namespace/DB sync or retry: {}", pending.dataItemId(), e.getMessage());
}
continue;
}
if (importDAO.enqueueIfMissing(pending.id32(), downloaded.rootTxId(), pending.height(),
downloaded.rawDataItem(), System.currentTimeMillis())) {
queued++;
}
unresolvedDownloads.remove(pending.dataItemId());
}
if (queued > 0) {
log.info("Fast Arweave retry queued {} signed DataItems; {} still unresolved", queued, unresolvedDownloads.size());
}
return queued;
}
private void drainQueue() throws Exception {
int passes = 0;
int importedTotal = 0;
boolean progress;
Set<String> replayedLogins = new HashSet<>();
do {
progress = false;
// Phase 1 is global: validate every pending DataItem and discover all signed segment
// ancestry before any canonical/orphan decision is made.
prepareAllSegmentMetadata();
// Phase 2 is deterministic logical replay order, never Arweave height/order.
List<ArweaveBlockImportDAO.QueueItem> pending = importDAO.listPendingValidated(cfg.syncQueueBatchSize());
if (pending.isEmpty()) break;
for (ArweaveBlockImportDAO.QueueItem q : pending) {
if (q.parsedLogin() == null || q.parsedForkNumber() == null || q.parsedBlockNumber() == null) continue;
SolanaUserPdaCurrentEntry activeUser = usersDAO.getByLogin(q.parsedLogin());
if (activeUser == null || activeUser.getBlockchainName() == null || activeUser.getBlockchainName().isBlank()) {
importDAO.setPendingError(q.dataItemId(), "active_user_missing", System.currentTimeMillis());
continue;
}
int activeFork = forkOf(activeUser.getBlockchainName());
if (!isAncestryComplete(q.parsedLogin(), activeFork)) {
importDAO.setPendingError(q.dataItemId(), "ancestry_incomplete", System.currentTimeMillis());
continue;
}
int canonicalFork;
try (Connection cc = DbController.getInstance().getConnection()) {
canonicalFork = canonical.resolveFork(cc, q.parsedLogin(), activeFork, q.parsedBlockNumber());
}
if (canonicalFork != q.parsedForkNumber()) {
importDAO.reject(q.dataItemId(), "orphan_noncanonical", System.currentTimeMillis());
progress = true;
continue;
}
Ans104DataItem item;
BchBlockEntry parsedBlock;
try {
item = new Ans104DataItem(q.rawDataItem());
parsedBlock = new BchBlockEntry(q.rawDataItem());
} catch (Exception e) {
// Should be impossible after metadata validation, but never trust persisted bytes blindly.
importDAO.reject(q.dataItemId(), "validated_item_reparse_failed: " + e.getMessage(), System.currentTimeMillis());
progress = true;
continue;
}
SolanaUserPdaCurrentEntry physicalUser = usersDAO.getByBlockchainKey(item.owner32());
if (physicalUser == null || physicalUser.getBlockchainName() == null
|| !q.parsedLogin().equalsIgnoreCase(physicalUser.getLogin())
|| forkOf(physicalUser.getBlockchainName()) != q.parsedForkNumber()) {
importDAO.reject(q.dataItemId(), "validated_owner_mapping_changed", System.currentTimeMillis());
progress = true;
continue;
}
ensureState(physicalUser, parsedBlock);
Net_AddBlock_Handler.ArweaveImportResult result = addBlock.addBlockFromReplay(
physicalUser.getBlockchainName(), q.rawDataItem());
if (result.ok()) {
importDAO.delete(q.dataItemId());
importedTotal++;
replayedLogins.add(q.parsedLogin());
progress = true;
rebuildIfLocalOrphansExist(q.parsedLogin(), activeFork);
continue;
}
String reason = result.reasonCode();
if ("bad_block_number".equals(reason) || "bad_prev_hash".equals(reason)
|| "prev_line_block_not_found".equals(reason) || "channel_not_found".equals(reason)
|| "chain_resync_in_progress".equals(reason)) {
importDAO.setPendingError(q.dataItemId(), reason, System.currentTimeMillis());
} else {
importDAO.reject(q.dataItemId(), reason, System.currentTimeMillis());
progress = true;
}
}
passes++;
} while (progress && passes < 1000);
// Replay deliberately suppresses live unread/push side effects. Recompute the server-owned
// unread projection from final canonical channel contents and preserved signed read_count.
if (!replayedLogins.isEmpty()) {
try (Connection c = DbController.getInstance().getConnection()) {
boolean ac = c.getAutoCommit(); c.setAutoCommit(false);
try {
for (String login : replayedLogins) {
ChannelReadStateDAO.getInstance().recalculateUnreadForOwnedChannels(c, login, System.currentTimeMillis());
}
c.commit();
} catch (Exception e) {
c.rollback(); throw e;
} finally { c.setAutoCommit(ac); }
}
}
if (importedTotal > 0) log.info("Imported {} SHiNE test DataItems from Arweave", importedTotal);
}
/**
* Phase 1 of Arweave recovery: scan the complete persistent PENDING queue and register only
* immutable segment ancestry metadata. No block is applied or rejected here.
*/
private void prepareAllSegmentMetadata() throws Exception {
String sql = "SELECT data_item_id,raw_data_item FROM arweave_block_import_queue WHERE status=? AND metadata_validated=FALSE ORDER BY block_height DESC, first_seen_at_ms DESC";
try (Connection c = DbController.getInstance().getConnection();
PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, ArweaveBlockImportDAO.STATUS_PENDING);
ps.setFetchSize(Math.max(100, cfg.syncQueueBatchSize()));
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
byte[] id = rs.getBytes(1);
byte[] raw = rs.getBytes(2);
if (raw == null || raw.length == 0) {
importDAO.reject(id, "empty_data_item", System.currentTimeMillis());
continue;
}
try {
// Metadata is trusted only after complete ANS-104 validation.
Ans104DataItem item = new Ans104DataItem(raw);
if (!Arrays.equals(item.id32(), id)) throw new IllegalArgumentException("data_item_id mismatch");
if (!item.hasTag(ArweaveBlocksConfig.TEST_TAG_NAME, ArweaveBlocksConfig.TEST_TAG_VALUE))
throw new IllegalArgumentException("bad App tag");
if (!item.verifySignature()) throw new IllegalArgumentException("bad ANS-104 signature");
BchBlockEntry b = new BchBlockEntry(raw);
SolanaUserPdaCurrentEntry owner = usersDAO.getByBlockchainKey(item.owner32());
if (owner == null || owner.getBlockchainName() == null || owner.getLogin() == null) {
importDAO.setPendingError(id, "unknown_owner", System.currentTimeMillis());
continue;
}
int fork = forkOf(owner.getBlockchainName());
// Only signed structural anchor blocks can create/modify ancestry metadata.
if (fork == 1 && b.blockNumber == 0) {
if (!(b.body instanceof blockchain.body.HeaderBody))
throw new IllegalArgumentException("fork1 block #0 is not HEADER");
segmentsDAO.upsert(c, new BlockchainForkSegmentsDAO.Segment(
owner.getLogin(), 1, null, -1, null, 0, System.currentTimeMillis()));
} else if (b.body instanceof blockchain.body.ForkBody fb) {
if (fork <= 1) throw new IllegalArgumentException("TECH_FORK cannot belong to fork1");
if (b.blockNumber != fb.forkPointBlockNumber + 1)
throw new IllegalArgumentException("TECH_FORK block number/fork point mismatch");
SolanaUserPdaCurrentEntry parent = usersDAO.getByBlockchainKey(fb.parentBlockchainKey32);
if (parent == null || parent.getBlockchainName() == null
|| !owner.getLogin().equalsIgnoreCase(parent.getLogin()))
throw new IllegalArgumentException("TECH_FORK parent owner mismatch");
int parentFork = forkOf(parent.getBlockchainName());
if (parentFork >= fork) throw new IllegalArgumentException("TECH_FORK parent fork is not older");
segmentsDAO.upsert(c, new BlockchainForkSegmentsDAO.Segment(
owner.getLogin(), fork, parentFork,
fb.forkPointBlockNumber, fb.forkPointBlockHash32,
fb.forkPointBlockNumber + 1, System.currentTimeMillis()));
}
importDAO.markMetadataValidated(id, owner.getLogin(), fork, b.blockNumber, b.getHash32(), System.currentTimeMillis());
} catch (Exception e) {
importDAO.reject(id, "invalid_data_item: " + e.getMessage(), System.currentTimeMillis());
}
}
}
}
}
/** True only when rotation ancestry is known all the way back to fork1. */
private boolean isAncestryComplete(String login, int activeFork) throws Exception {
int f = activeFork;
Set<Integer> seen = new HashSet<>();
while (true) {
if (f < 1 || !seen.add(f)) return false;
BlockchainForkSegmentsDAO.Segment seg = segmentsDAO.get(login, f);
if (seg == null) return false;
if (seg.parentForkNumber() == null) {
return f == 1 && seg.firstPhysicalBlockNumber() == 0;
}
f = seg.parentForkNumber();
}
}
private void ensureState(SolanaUserPdaCurrentEntry user, BchBlockEntry firstSeen) throws Exception {
int fork=forkOf(user.getBlockchainName()); BlockchainStateEntry s=new BlockchainStateEntry();
s.setBlockchainName(user.getBlockchainName());s.setLogin(user.getLogin());s.setBlockchainKey(user.getBlockchainKey());s.setSizeLimit(user.getPaidLimitBytes()>0?user.getPaidLimitBytes():100_000L);s.setFileSizeBytes(0L);
BlockchainForkSegmentsDAO.Segment seg=segmentsDAO.get(user.getLogin(),fork);
BlockchainStateEntry existing=stateDAO.getByBlockchainName(user.getBlockchainName());
if(existing!=null && (seg==null || seg.parentForkNumber()==null || existing.getLastBlockNumber()>=seg.forkPointBlockNumber()))return;
if(seg!=null&&seg.parentForkNumber()!=null){
s.setLastBlockNumber(seg.forkPointBlockNumber());s.setLastBlockHash(seg.forkPointBlockHash());
try(var c=shine.db.DbController.getInstance().getConnection();var ps=c.prepareStatement("SELECT COALESCE(SUM(octet_length(block_bytes)),0) FROM blocks_store WHERE LOWER(login)=LOWER(?) AND block_number<=? AND fork_number=shine_canonical_fork(?,?,block_number)")){
ps.setString(1,user.getLogin());ps.setInt(2,seg.forkPointBlockNumber());ps.setString(3,user.getLogin());ps.setInt(4,seg.parentForkNumber());try(var rs=ps.executeQuery()){if(rs.next())s.setFileSizeBytes(rs.getLong(1));}
}
} else{s.setLastBlockNumber(-1);s.setLastBlockHash(null);}
s.setUpdatedAtMs(System.currentTimeMillis());stateDAO.insertIfMissing(s);
if(existing!=null)stateDAO.upsert(s);
}
private static int forkOf(String n){int d=n.lastIndexOf('-');return Integer.parseInt(n.substring(d+1));}
/** Resume a durable canonical rebuild that was interrupted after staging/cleanup/replay. */
private void recoverInterruptedCanonicalRebuilds() throws Exception {
List<String> logins=new ArrayList<>();
try(Connection c=DbController.getInstance().getConnection();
PreparedStatement ps=c.prepareStatement("SELECT DISTINCT login FROM canonical_rebuild_staging ORDER BY login");
ResultSet rs=ps.executeQuery()){
while(rs.next())logins.add(rs.getString(1));
}
for(String login:logins){
SolanaUserPdaCurrentEntry u=usersDAO.getByLogin(login);
if(u==null||u.getBlockchainName()==null)continue;
replayDurableCanonicalStaging(login,forkOf(u.getBlockchainName()));
}
}
/**
* A server may learn a deep fork only through Arweave after already materializing the old branch.
* If any local raw block is non-canonical under the current PDA fork, stage the canonical raw set
* and rebuild projections exactly like local key rotation does.
*/
private void rebuildIfLocalOrphansExist(String login,int activeFork)throws Exception{
if(!hasNonCanonicalLocalBlocks(login,activeFork))return;
if(!hasGenericStaging(login))stageLocalCanonicalBlocks(login,activeFork);
validateGenericStaging(login);
replayDurableCanonicalStaging(login,activeFork);
}
private boolean hasNonCanonicalLocalBlocks(String login,int activeFork)throws SQLException{
String sql="SELECT 1 FROM blocks_store b WHERE LOWER(b.login)=LOWER(?) AND b.fork_number<>shine_canonical_fork(?,?,b.block_number) LIMIT 1";
try(Connection c=DbController.getInstance().getConnection();PreparedStatement ps=c.prepareStatement(sql)){
ps.setString(1,login);ps.setString(2,login);ps.setInt(3,activeFork);try(ResultSet rs=ps.executeQuery()){return rs.next();}
}
}
private boolean hasGenericStaging(String login)throws SQLException{
try(Connection c=DbController.getInstance().getConnection();PreparedStatement ps=c.prepareStatement("SELECT 1 FROM canonical_rebuild_staging WHERE LOWER(login)=LOWER(?) LIMIT 1")){
ps.setString(1,login);try(ResultSet rs=ps.executeQuery()){return rs.next();}
}
}
private void stageLocalCanonicalBlocks(String login,int activeFork)throws Exception{
try(Connection c=DbController.getInstance().getConnection()){boolean ac=c.getAutoCommit();c.setAutoCommit(false);try{
try(PreparedStatement d=c.prepareStatement("DELETE FROM canonical_rebuild_staging WHERE LOWER(login)=LOWER(?)")){d.setString(1,login);d.executeUpdate();}
String q="""
SELECT block_number,fork_number,block_bytes,block_hash
FROM blocks_store b
WHERE LOWER(login)=LOWER(?) AND fork_number=shine_canonical_fork(?,?,block_number)
ORDER BY block_number ASC
""";
String ins="INSERT INTO canonical_rebuild_staging(login,logical_block_number,physical_fork_number,block_bytes,block_hash) VALUES(?,?,?,?,?)";
try(PreparedStatement ps=c.prepareStatement(q);PreparedStatement out=c.prepareStatement(ins)){
ps.setString(1,login);ps.setString(2,login);ps.setInt(3,activeFork);
try(ResultSet rs=ps.executeQuery()){while(rs.next()){
out.setString(1,login);out.setInt(2,rs.getInt(1));out.setInt(3,rs.getInt(2));out.setBytes(4,rs.getBytes(3));out.setBytes(5,rs.getBytes(4));out.addBatch();
}}out.executeBatch();
}
c.commit();
}catch(Exception e){c.rollback();throw e;}finally{c.setAutoCommit(ac);}}
}
private void validateGenericStaging(String login)throws Exception{
int expected=0,last=-1;byte[] previous=null;
try(Connection c=DbController.getInstance().getConnection();PreparedStatement ps=c.prepareStatement("SELECT logical_block_number,block_bytes,block_hash FROM canonical_rebuild_staging WHERE LOWER(login)=LOWER(?) ORDER BY logical_block_number ASC")){
ps.setString(1,login);try(ResultSet rs=ps.executeQuery()){while(rs.next()){
int n=rs.getInt(1);byte[] raw=rs.getBytes(2),hash=rs.getBytes(3);if(n!=expected)throw new IllegalStateException("canonical staging gap for "+login+": expected #"+expected+" got #"+n);
BchBlockEntry b=new BchBlockEntry(raw);if(b.blockNumber!=n)throw new IllegalStateException("canonical staging block mismatch #"+n);
if(n==0&&!(b.body instanceof blockchain.body.HeaderBody))throw new IllegalStateException("canonical staging must start HEADER #0");
if(n>0&&(previous==null||!Arrays.equals(b.prevHash32,previous)))throw new IllegalStateException("canonical staging prevHash mismatch #"+n);
if(hash==null||hash.length!=32||!Arrays.equals(hash,b.getHash32()))throw new IllegalStateException("canonical staging hash mismatch #"+n);
previous=hash;last=n;expected++;
}}
}
if(last<0)throw new IllegalStateException("canonical staging is empty for "+login);
}
private void replayDurableCanonicalStaging(String login,int activeFork)throws Exception{
SolanaUserPdaCurrentEntry u=usersDAO.getByLogin(login);if(u==null)throw new IllegalStateException("user missing for canonical rebuild: "+login);
String activeName=u.getBlockchainName();boolean guard=BlockchainResyncGuard.tryBegin(activeName);if(!guard)throw new IllegalStateException("canonical rebuild already active: "+login);
try{
validateGenericStaging(login);
cleanupDAO.cleanupLoginForCanonicalReplay(login);
long limit=u.getPaidLimitBytes()>0?u.getPaidLimitBytes():100_000L,cumulative=0;int currentFork=-1,prevNumber=-1;byte[] prevHash=null;
try(Connection c=DbController.getInstance().getConnection();PreparedStatement ps=c.prepareStatement("SELECT logical_block_number,physical_fork_number,block_bytes,block_hash FROM canonical_rebuild_staging WHERE LOWER(login)=LOWER(?) ORDER BY logical_block_number ASC")){
ps.setString(1,login);try(ResultSet rs=ps.executeQuery()){while(rs.next()){
int n=rs.getInt(1),f=rs.getInt(2);byte[] raw=rs.getBytes(3),hash=rs.getBytes(4);BchBlockEntry b=new BchBlockEntry(raw);
String bch=login+"-"+String.format("%03d",f);
if(f!=currentFork){BlockchainStateEntry st=new BlockchainStateEntry();st.setBlockchainName(bch);st.setLogin(login);st.setBlockchainKey(Base64.getEncoder().encodeToString(b.getOwner32()));st.setSizeLimit(limit);st.setFileSizeBytes(cumulative);st.setLastBlockNumber(prevNumber);st.setLastBlockHash(prevHash);st.setUpdatedAtMs(System.currentTimeMillis());stateDAO.insertIfMissing(st);currentFork=f;}
Net_AddBlock_Handler.ArweaveImportResult r=addBlock.addBlockFromReplay(bch,raw);if(!r.ok())throw new IllegalStateException("canonical Arweave rebuild rejected #"+n+": "+r.reasonCode());
cumulative+=raw.length;prevNumber=n;prevHash=hash;
}}
}
cleanupDAO.finalizeCanonicalReplay(login);
try(Connection c=DbController.getInstance().getConnection();PreparedStatement ps=c.prepareStatement("DELETE FROM canonical_rebuild_staging WHERE LOWER(login)=LOWER(?)")){ps.setString(1,login);ps.executeUpdate();}
}finally{BlockchainResyncGuard.end(activeName);}
}
/** Независимый GraphQL курсор для t=reg: не смешивается с блоковой очередью. */
private void discoverFreeRegistrations() throws Exception {
long stored;
try (Connection c = DbController.getInstance().getConnection();
PreparedStatement ps = c.prepareStatement(
"SELECT last_block_height FROM free_registration_arweave_sync_state WHERE id=1");
ResultSet rs = ps.executeQuery()) {
stored = rs.next() ? rs.getLong(1) : 0;
}
long minHeight = Math.max(cfg.syncStartBlockHeight(), stored);
long high = minHeight;
long retryFrom = Long.MAX_VALUE;
String cursor = null;
int count = 0;
do {
JsonNode response = graphQlPage(minHeight, cursor, true);
if (response.has("errors")) throw new IOException("Registration GraphQL errors: " + response.path("errors"));
JsonNode txs = response.path("data").path("transactions");
JsonNode edges = txs.path("edges");
if (!edges.isArray()) throw new IOException("Registration GraphQL returned no edges");
String next = null;
for (JsonNode edge : edges) {
next = edge.path("cursor").asText(null);
JsonNode node = edge.path("node");
String id = node.path("id").asText("").trim();
long height = node.path("block").path("height").asLong(-1);
if (id.isBlank() || height < 0) continue; // мгновенный Turbo-импорт не зависит от height
high = Math.max(high, height);
try {
byte[] idBytes = B64URL.decode(id);
if (idBytes.length != 32) throw new IllegalArgumentException("Malformed id");
DownloadedDataItem item = downloadSignedDataItem(id);
if (!isRegistrationItem(item.rawDataItem()))
throw new IllegalArgumentException("GraphQL registration tag is not present in signed bytes");
registrationImporter.importSigned(item.rawDataItem(),
VerifiedFreeRegistrationImporter.Provenance.ARWEAVE_CONFIRMED);
count++;
} catch (RetryableDataItemDownloadException e) {
retryFrom = Math.min(retryFrom, height);
log.debug("Registration DataItem {} is not downloadable yet", id);
} catch (IllegalArgumentException e) {
log.warn("Rejecting invalid registration DataItem {}: {}", id, e.getMessage());
} catch (Exception e) {
retryFrom = Math.min(retryFrom, height);
log.warn("Registration DataItem {} import deferred: {}", id, e.getMessage());
}
}
cursor = txs.path("pageInfo").path("hasNextPage").asBoolean(false) ? next : null;
if (txs.path("pageInfo").path("hasNextPage").asBoolean(false) && (cursor == null || cursor.isBlank()))
throw new IOException("Registration GraphQL cursor missing");
} while (cursor != null);
long checkpoint = retryFrom == Long.MAX_VALUE ? high : Math.min(high, retryFrom);
try (Connection c = DbController.getInstance().getConnection();
PreparedStatement ps = c.prepareStatement("""
UPDATE free_registration_arweave_sync_state
SET last_block_height=?, updated_at_ms=? WHERE id=1
""")) {
ps.setLong(1, checkpoint); ps.setLong(2, System.currentTimeMillis()); ps.executeUpdate();
}
if (count > 0) log.info("Registration discovery verified {} DataItems; checkpoint={}", count, checkpoint);
}
private static boolean isRegistrationItem(byte[] raw) {
Ans104DataItem item = new Ans104DataItem(raw);
return item.tags().contains(new Ans104DataItem.Tag("t", "reg"));
}
private JsonNode graphQlPage(long minHeight, String cursor) throws Exception {
return graphQlPage(minHeight, cursor, false);
}
private JsonNode graphQlPage(long minHeight, String cursor, boolean registrationsOnly) throws Exception {
String after = cursor == null ? "null" : "\"" + escapeGraphQl(cursor) + "\"";
String tagFilter = "{name:\"" + ArweaveBlocksConfig.TEST_TAG_NAME + "\",values:[\""
+ ArweaveBlocksConfig.TEST_TAG_VALUE + "\"]}" +
(registrationsOnly ? ",{name:\"t\",values:[\"reg\"]}" : "");
String query = "query { transactions(tags:[" + tagFilter + "], block:{min:" + minHeight + "}, first:"
+ cfg.syncPageSize() + ", after:" + after
+ ", sort:HEIGHT_ASC) { pageInfo { hasNextPage } edges { cursor node { id block { height } } } } }";
String body = MAPPER.writeValueAsString(Map.of("query", query));
HttpRequest req = HttpRequest.newBuilder(URI.create(trim(cfg.syncGateway()) + "/graphql"))
.timeout(Duration.ofSeconds(60)).header("Content-Type","application/json").header("Accept","application/json")
.POST(HttpRequest.BodyPublishers.ofString(body, StandardCharsets.UTF_8)).build();
HttpResponse<String> resp = http.send(req, HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
if (resp.statusCode() < 200 || resp.statusCode() >= 300) throw new IOException("GraphQL HTTP " + resp.statusCode());
return MAPPER.readTree(resp.body());
}
/**
* Gateway по /{dataItemId} обычно отдаёт только payload. Для импорта SHiNE нужен полный
* подписанный ANS-104 DataItem, поэтому сначала резолвим rootTx + offset + size, а затем
* читаем точный range из root L1 transaction.
*/
private DownloadedDataItem downloadSignedDataItem(String dataItemId) throws Exception {
DataItemLocation location = resolveDataItemLocation(dataItemId);
long endInclusive = location.rootOffset() + location.size() - 1;
HttpRequest req = HttpRequest.newBuilder(URI.create(trim(cfg.syncGateway()) + "/raw/" + location.rootTxId()))
.timeout(Duration.ofMinutes(2))
.header("Range", "bytes=" + location.rootOffset() + "-" + endInclusive)
.header("Accept", "application/octet-stream")
.GET().build();
HttpResponse<InputStream> resp = http.send(req, HttpResponse.BodyHandlers.ofInputStream());
try (InputStream in = resp.body()) {
if (resp.statusCode() != 206) {
if (isRetryableHttpStatus(resp.statusCode())) {
throw new RetryableDataItemDownloadException(
"root range is temporarily unavailable via " + location.source() + ": HTTP " + resp.statusCode());
}
throw new IOException("Gateway ignored root range for DataItem " + dataItemId + ": HTTP " + resp.statusCode());
}
byte[] bytes = readExactlyBounded(in, Math.toIntExact(location.size()));
if (bytes.length != location.size()) {
throw new RetryableDataItemDownloadException(
"truncated DataItem range: expected=" + location.size() + " got=" + bytes.length);
}
Ans104DataItem parsed = new Ans104DataItem(bytes);
byte[] expectedId = B64URL.decode(dataItemId);
if (!Arrays.equals(parsed.id32(), expectedId)) {
throw new IOException("Range returned another ANS-104 DataItem for " + dataItemId);
}
return new DownloadedDataItem(location.rootTxId(), bytes);
}
}
/**
* Координаты считаются только подсказкой транспорта: источник может ошибиться, поэтому после
* range-read всё равно обязательно сверяется настоящий ANS-104 DataItem ID и затем подпись.
*/
private DataItemLocation resolveDataItemLocation(String dataItemId) throws Exception {
List<String> misses = new ArrayList<>(3);
try {
DataItemLocation location = getArIoIndexedLocation(dataItemId);
if (location != null) return location;
misses.add("ar-io=404");
} catch (Exception e) {
misses.add("ar-io=" + shortError(e));
}
try {
DataItemLocation location = getTurboLocation(dataItemId);
if (location != null) return location;
misses.add("turbo=404");
} catch (Exception e) {
misses.add("turbo=" + shortError(e));
}
try {
DataItemLocation location = getHeadLocation(dataItemId);
if (location != null) return location;
misses.add("head=no-location");
} catch (Exception e) {
misses.add("head=" + shortError(e));
}
throw new RetryableDataItemDownloadException(
"ANS-104 location not available yet (" + String.join(", ", misses) + ")");
}
/** Самый дешёвый путь: локальный индекс AR.IO gateway. */
private DataItemLocation getArIoIndexedLocation(String dataItemId) throws Exception {
HttpRequest req = HttpRequest.newBuilder(URI.create(trim(cfg.syncGateway()) + "/ar-io/offsets/" + dataItemId))
.timeout(Duration.ofSeconds(30)).header("Accept", "application/json").GET().build();
HttpResponse<String> resp = http.send(req, HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
if (resp.statusCode() == 404) return null;
if (resp.statusCode() < 200 || resp.statusCode() >= 300) {
throw new IOException("HTTP " + resp.statusCode() + ": " + safe(resp.body()));
}
JsonNode offsets = MAPPER.readTree(resp.body());
return validateLocation("ar-io", dataItemId,
offsets.path("rootTxId").asText("").trim(),
offsets.path("rootOffset").asLong(-1L),
offsets.path("size").asLong(-1L));
}
/** Turbo часто знает координаты раньше общего gateway index. */
private DataItemLocation getTurboLocation(String dataItemId) throws Exception {
HttpRequest req = HttpRequest.newBuilder(URI.create(trim(cfg.syncTurboApiBase()) + "/tx/" + dataItemId + "/offsets"))
.timeout(Duration.ofSeconds(30)).header("Accept", "application/json").GET().build();
HttpResponse<String> resp = http.send(req, HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
if (resp.statusCode() == 404) return null;
if (resp.statusCode() < 200 || resp.statusCode() >= 300) {
throw new IOException("HTTP " + resp.statusCode() + ": " + safe(resp.body()));
}
JsonNode offsets = MAPPER.readTree(resp.body());
return validateLocation("turbo", dataItemId,
offsets.path("rootBundleId").asText("").trim(),
offsets.path("startOffsetInRootBundle").asLong(-1L),
offsets.path("rawContentLength").asLong(-1L));
}
/**
* Последний fallback: успешный HEAD/GET AR.IO может вернуть координаты DataItem в headers.
* Поддерживаем несколько имён headers, чтобы пережить различия версий gateway.
*/
private DataItemLocation getHeadLocation(String dataItemId) throws Exception {
HttpRequest req = HttpRequest.newBuilder(URI.create(trim(cfg.syncGateway()) + "/" + dataItemId))
.timeout(Duration.ofSeconds(45))
.header("Accept", "application/octet-stream")
.method("HEAD", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse<Void> resp = http.send(req, HttpResponse.BodyHandlers.discarding());
if (resp.statusCode() == 404) return null;
if (resp.statusCode() < 200 || resp.statusCode() >= 300) {
throw new IOException("HTTP " + resp.statusCode());
}
String rootTxId = firstHeader(resp, "X-AR-IO-Root-Transaction-Id");
long offset = firstLongHeader(resp,
"X-AR-IO-Root-Item-Offset",
"X-AR-IO-Root-Data-Item-Offset",
"X-AR-IO-Data-Item-Offset");
long size = firstLongHeader(resp,
"X-AR-IO-Root-Item-Size",
"X-AR-IO-Data-Item-Size");
if (rootTxId == null || offset < 0 || size <= 0) return null;
return validateLocation("head", dataItemId, rootTxId, offset, size);
}
private DataItemLocation validateLocation(String source, String dataItemId, String rootTxId, long rootOffset, long size)
throws IOException {
if (!isArweaveId(rootTxId) || rootOffset < 0 || size <= 0) {
throw new IOException("bad location for " + dataItemId + ": rootTxId=" + rootTxId
+ " offset=" + rootOffset + " size=" + size);
}
if (size > cfg.syncMaxDataItemBytes()) {
throw new IOException("DataItem exceeds syncMaxDataItemBytes: " + size);
}
if (size > Integer.MAX_VALUE) throw new IOException("DataItem is too large for in-memory import: " + size);
if (rootOffset > Long.MAX_VALUE - size) throw new IOException("DataItem offset overflow");
return new DataItemLocation(rootTxId, rootOffset, size, source);
}
private static String firstHeader(HttpResponse<?> response, String name) {
return response.headers().firstValue(name).map(String::trim).filter(v -> !v.isEmpty()).orElse(null);
}
private static long firstLongHeader(HttpResponse<?> response, String... names) {
for (String name : names) {
String value = firstHeader(response, name);
if (value == null) continue;
try { return Long.parseLong(value); }
catch (NumberFormatException ignored) { }
}
return -1L;
}
private static boolean isArweaveId(String value) {
if (value == null || value.length() != 43) return false;
try { return B64URL.decode(value).length == 32; }
catch (IllegalArgumentException e) { return false; }
}
private static boolean isRetryableHttpStatus(int status) {
return status == 404 || status == 408 || status == 425 || status == 429 || status >= 500;
}
private static String shortError(Exception e) {
String message = e.getMessage();
return safe(message == null || message.isBlank() ? e.getClass().getSimpleName() : message);
}
private record PendingDownload(String dataItemId, byte[] id32, long height) {}
private record DownloadedDataItem(String rootTxId, byte[] rawDataItem) {}
private record DataItemLocation(String rootTxId, long rootOffset, long size, String source) {}
private static final class RetryableDataItemDownloadException extends IOException {
private RetryableDataItemDownloadException(String message) { super(message); }
}
private static byte[] readExactlyBounded(InputStream in, int expected) throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream(expected);
byte[] buf = new byte[Math.min(64 * 1024, Math.max(1024, expected))];
int remaining = expected;
while (remaining > 0) {
int n = in.read(buf, 0, Math.min(buf.length, remaining));
if (n < 0) break;
out.write(buf, 0, n);
remaining -= n;
}
return out.toByteArray();
}
private static String safe(String value) {
String v = value == null ? "" : value.replace('\n',' ').replace('\r',' ').trim();
return v.length() <= 500 ? v : v.substring(0, 500);
}
private static String trim(String s){return String.valueOf(s==null?"":s).trim().replaceAll("/+$","");}
private static String escapeGraphQl(String s){return s.replace("\\","\\\\").replace("\"","\\\"");}
}
@@ -1,104 +0,0 @@
package server.archive;
import blockchain.Ans104DataItem;
import blockchain.ShineProtocolTags;
import utils.config.AppConfig;
import java.nio.file.Path;
import java.util.Locale;
/** Configuration of per-user-block ANS-104 Arweave/Turbo transport. */
public record ArweaveBlocksConfig(
PublishMode publishMode,
int publishIntervalMinutes,
int publishMaxItems,
long publishMaxBundleBytes,
String publishGateway,
Path walletJwkPath,
int minConfirmations,
int confirmPollSeconds,
int confirmTimeoutMinutes,
String turboUploadUrl,
String turboPaidByAddress,
Path turboWalletJwkPath,
boolean syncEnabled,
int syncIntervalMinutes,
int syncPageSize,
int syncQueueBatchSize,
long syncStartBlockHeight,
long syncMaxDataItemBytes,
String syncGateway,
String syncTurboApiBase,
int syncLocationRetrySeconds
) {
public enum PublishMode {
TURBO,
ARWEAVE,
NONE;
static PublishMode parse(String value) {
String normalized = value == null ? "none" : value.trim().toLowerCase(Locale.ROOT);
return switch (normalized) {
case "turbo" -> TURBO;
case "arweave" -> ARWEAVE;
case "none", "" -> NONE;
default -> throw new IllegalArgumentException(
"arweave.blocks.publish.mode must be turbo, arweave or none; got: " + value);
};
}
}
public static final String TEST_TAG_NAME = ShineProtocolTags.APP_TAG_NAME;
public static final String TEST_TAG_VALUE = ShineProtocolTags.APP_TAG_VALUE;
public static final String CHANNEL_TAG_NAME = ShineProtocolTags.CHANNEL_TAG_NAME;
public static ArweaveBlocksConfig load() {
AppConfig c = AppConfig.getInstance();
long maxDataItemBytes = parseLong(c.getParam("arweave.blocks.sync.maxDataItemBytes"), Ans104DataItem.MAX_DATA_ITEM_BYTES);
if (maxDataItemBytes > Ans104DataItem.MAX_DATA_ITEM_BYTES) maxDataItemBytes = Ans104DataItem.MAX_DATA_ITEM_BYTES;
return new ArweaveBlocksConfig(
PublishMode.parse(c.getParam("arweave.blocks.publish.mode")),
positive(c.getInt("arweave.blocks.publish.intervalMinutes", 15), "publish.intervalMinutes"),
positive(c.getInt("arweave.blocks.publish.maxItems", 10_000), "publish.maxItems"),
positiveLong(parseLong(c.getParam("arweave.blocks.publish.maxBundleBytes"), 128L * 1024 * 1024), "publish.maxBundleBytes"),
orDefault(c.getParam("arweave.blocks.publish.gateway"), "https://arweave.net"),
optionalPath(c.getParam("arweave.blocks.publish.walletJwkPath")),
nonNegative(c.getInt("arweave.blocks.publish.minConfirmations", 0), "publish.minConfirmations"),
positive(c.getInt("arweave.blocks.publish.confirmPollSeconds", 30), "publish.confirmPollSeconds"),
positive(c.getInt("arweave.blocks.publish.confirmTimeoutMinutes", 180), "publish.confirmTimeoutMinutes"),
orDefault(c.getParam("arweave.blocks.publish.turbo.uploadUrl"), "https://turbo.ardrive.io/tx"),
blankToNull(c.getParam("arweave.blocks.publish.turbo.paidByAddress")),
optionalPath(c.getParam("arweave.blocks.publish.turbo.walletJwkPath")),
c.getBoolean("arweave.blocks.sync.enabled", false),
positive(c.getInt("arweave.blocks.sync.intervalMinutes", 15), "sync.intervalMinutes"),
clamp(c.getInt("arweave.blocks.sync.pageSize", 100), 1, 100),
positive(c.getInt("arweave.blocks.sync.queueBatchSize", 10_000), "sync.queueBatchSize"),
nonNegativeLong(parseLong(c.getParam("arweave.blocks.sync.startBlockHeight"), 0L), "sync.startBlockHeight"),
positiveLong(maxDataItemBytes, "sync.maxDataItemBytes"),
orDefault(c.getParam("arweave.blocks.sync.gateway"), "https://turbo-gateway.com"),
orDefault(c.getParam("arweave.blocks.sync.turboApiBase"), "https://turbo.ardrive.io"),
positive(c.getInt("arweave.blocks.sync.locationRetrySeconds", 30), "sync.locationRetrySeconds")
);
}
public boolean publishEnabled() { return publishMode != PublishMode.NONE; }
public void validatePublisher() {
if (publishMode == PublishMode.ARWEAVE && walletJwkPath == null) {
throw new IllegalArgumentException("arweave.blocks.publish.walletJwkPath is required for mode=arweave");
}
if (publishMode == PublishMode.TURBO && (turboUploadUrl == null || turboUploadUrl.isBlank())) {
throw new IllegalArgumentException("arweave.blocks.publish.turbo.uploadUrl is required for mode=turbo");
}
}
private static String orDefault(String v, String d) { return v == null || v.isBlank() ? d : v.trim(); }
private static String blankToNull(String v) { return v == null || v.isBlank() ? null : v.trim(); }
private static Path optionalPath(String v) { return v == null || v.isBlank() ? null : Path.of(v.trim()); }
private static long parseLong(String v, long d) { return v == null || v.isBlank() ? d : Long.parseLong(v.trim()); }
private static int positive(int v,String n){if(v<=0)throw new IllegalArgumentException(n+" must be >0");return v;}
private static int nonNegative(int v,String n){if(v<0)throw new IllegalArgumentException(n+" must be >=0");return v;}
private static long positiveLong(long v,String n){if(v<=0)throw new IllegalArgumentException(n+" must be >0");return v;}
private static long nonNegativeLong(long v,String n){if(v<0)throw new IllegalArgumentException(n+" must be >=0");return v;}
private static int clamp(int v,int min,int max){return Math.max(min,Math.min(max,v));}
}
@@ -1,141 +0,0 @@
package server.archive;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.math.BigInteger;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.security.*;
import java.security.spec.MGF1ParameterSpec;
import java.security.spec.PSSParameterSpec;
import java.security.spec.RSAPrivateCrtKeySpec;
import java.time.Duration;
import java.util.*;
/** Existing native Arweave L1 transport adapted to upload in-memory ANS-104 bundles. */
public final class ArweaveL1Uploader {
private static final Logger log = LoggerFactory.getLogger(ArweaveL1Uploader.class);
private static final ObjectMapper MAPPER = new ObjectMapper();
private static final Base64.Encoder B64 = Base64.getUrlEncoder().withoutPadding();
private static final Base64.Decoder B64D = Base64.getUrlDecoder();
public record Tag(String name, String value) {}
public record UploadResult(String txId, byte[] txIdBytes) {}
private final ArweaveBlocksConfig cfg;
private final HttpClient http = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(20)).build();
private volatile Wallet wallet;
public ArweaveL1Uploader(ArweaveBlocksConfig cfg) { this.cfg = Objects.requireNonNull(cfg); }
public UploadResult upload(byte[] data, List<Tag> tags) throws Exception {
if (data == null || data.length == 0) throw new IllegalArgumentException("Arweave upload data is empty");
Wallet w = wallet();
String gateway = trimGateway(cfg.publishGateway());
ArweaveMerkle.Prepared merkle = ArweaveMerkle.prepare(data);
String anchor = getRequiredText(gateway, "/tx_anchor");
String reward = getRequiredText(gateway, "/price/" + data.length);
if (!reward.matches("^\\d+$")) throw new IOException("Bad Arweave price: " + reward);
verifyBalance(gateway, w.address(), reward);
List<List<byte[]>> tagList = new ArrayList<>();
List<Map<String,String>> jsonTags = new ArrayList<>();
for (Tag tag : tags == null ? List.<Tag>of() : tags) addTag(jsonTags, tagList, tag.name(), tag.value());
byte[] signaturePayload = deepHash(List.of(
utf8("2"), b64Decode(w.owner()), new byte[0], utf8("0"), utf8(reward),
b64Decode(anchor), tagList, utf8(Integer.toString(data.length)), merkle.dataRoot()
));
byte[] rawSignature = signPayload(w.privateKey(), signaturePayload);
byte[] txIdBytes = sha256(rawSignature);
String txId = b64(txIdBytes);
Map<String,Object> tx = new LinkedHashMap<>();
tx.put("format",2); tx.put("id",txId); tx.put("last_tx",anchor); tx.put("owner",w.owner());
tx.put("tags",jsonTags); tx.put("target",""); tx.put("quantity","0");
tx.put("data_root",b64(merkle.dataRoot())); tx.put("data_size",Integer.toString(data.length)); tx.put("data","");
tx.put("reward",reward); tx.put("signature",b64(rawSignature));
postJsonExpect2xx(gateway + "/tx", tx, Duration.ofSeconds(60));
for (int i=0;i<merkle.chunks().size();i++) {
ArweaveMerkle.Chunk meta=merkle.chunks().get(i); ArweaveMerkle.Proof proof=merkle.proofs().get(i);
Map<String,Object> body=new LinkedHashMap<>();
body.put("data_root",b64(merkle.dataRoot())); body.put("data_size",Integer.toString(data.length));
body.put("data_path",b64(proof.proof())); body.put("offset",Long.toString(proof.offset()));
body.put("chunk",b64(ArweaveMerkle.readChunk(data,meta)));
postChunkWithRetry(gateway,body,i,merkle.chunks().size());
}
if (cfg.minConfirmations() > 0) waitForConfirmations(txId);
log.info("ANS-104 bundle uploaded to Arweave: tx={} bytes={} items-transported",txId,data.length);
return new UploadResult(txId,txIdBytes);
}
private int waitForConfirmations(String txId) throws Exception {
String gateway=trimGateway(cfg.publishGateway());
long deadline=System.currentTimeMillis()+cfg.confirmTimeoutMinutes()*60_000L; int last=0;
while(System.currentTimeMillis()<deadline){
HttpRequest req=HttpRequest.newBuilder(URI.create(gateway+"/tx/"+txId+"/status")).timeout(Duration.ofSeconds(20)).GET().build();
HttpResponse<String> resp=http.send(req,HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
if(resp.statusCode()==200){JsonNode j=MAPPER.readTree(resp.body());last=j.path("number_of_confirmations").asInt(0);if(last>=cfg.minConfirmations())return last;}
else if(resp.statusCode()!=202&&resp.statusCode()!=404)log.warn("Arweave status tx={} HTTP {}",txId,resp.statusCode());
Thread.sleep(cfg.confirmPollSeconds()*1000L);
}
throw new IOException("Arweave confirmation timeout for "+txId+", last="+last);
}
private void postChunkWithRetry(String gateway,Map<String,Object> body,int index,int total)throws Exception{
Exception last=null;
for(int attempt=1;attempt<=12;attempt++)try{postJsonExpect2xx(gateway+"/chunk",body,Duration.ofSeconds(60));return;}catch(Exception e){last=e;if(attempt==12)break;Thread.sleep(5000L);}
throw new IOException("Failed Arweave chunk "+(index+1)+"/"+total,last);
}
private void postJsonExpect2xx(String url,Object body,Duration timeout)throws Exception{
HttpRequest req=HttpRequest.newBuilder(URI.create(url)).timeout(timeout).header("Content-Type","application/json").header("Accept","application/json")
.POST(HttpRequest.BodyPublishers.ofString(MAPPER.writeValueAsString(body),StandardCharsets.UTF_8)).build();
HttpResponse<String> resp=http.send(req,HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
if(resp.statusCode()<200||resp.statusCode()>=300)throw new IOException("HTTP "+resp.statusCode()+" "+safe(resp.body()));
}
private void verifyBalance(String gateway,String address,String reward)throws Exception{
String balance=getRequiredText(gateway,"/wallet/"+address+"/balance");
if(balance.matches("^\\d+$")&&new BigInteger(balance).compareTo(new BigInteger(reward))<0)throw new IllegalStateException("Not enough AR: balance="+balance+" reward="+reward);
}
private String getRequiredText(String gateway,String path)throws Exception{
HttpRequest req=HttpRequest.newBuilder(URI.create(gateway+path)).timeout(Duration.ofSeconds(20)).GET().build();
HttpResponse<String> resp=http.send(req,HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
if(resp.statusCode()<200||resp.statusCode()>=300)throw new IOException("Arweave HTTP "+resp.statusCode()+" for "+path+": "+safe(resp.body()));
String s=resp.body()==null?"":resp.body().trim();if(s.isBlank())throw new IOException("Empty Arweave response for "+path);return s;
}
private Wallet wallet()throws Exception{
Wallet local=wallet;if(local!=null)return local;synchronized(this){if(wallet!=null)return wallet;
JsonNode jwk=MAPPER.readTree(Files.readString(cfg.walletJwkPath(),StandardCharsets.UTF_8));String owner=required(jwk,"n");
PrivateKey pk=buildPrivateKey(jwk);String address=b64(sha256(b64Decode(owner)));return wallet=new Wallet(owner,address,pk);}
}
private static PrivateKey buildPrivateKey(JsonNode jwk)throws GeneralSecurityException{
RSAPrivateCrtKeySpec spec=new RSAPrivateCrtKeySpec(big(required(jwk,"n")),big(required(jwk,"e")),big(required(jwk,"d")),big(required(jwk,"p")),big(required(jwk,"q")),big(required(jwk,"dp")),big(required(jwk,"dq")),big(required(jwk,"qi")));
return KeyFactory.getInstance("RSA").generatePrivate(spec);
}
private static byte[] signPayload(PrivateKey key,byte[] payload)throws GeneralSecurityException{
Signature s=Signature.getInstance("RSASSA-PSS");s.setParameter(new PSSParameterSpec("SHA-256","MGF1",MGF1ParameterSpec.SHA256,32,1));s.initSign(key);s.update(payload);return s.sign();
}
private static byte[] deepHash(Object data)throws GeneralSecurityException{
if(data instanceof List<?> list){byte[] acc=sha384(utf8("list"+list.size()));for(Object item:list)acc=sha384(concat(acc,deepHash(item)));return acc;}
if(!(data instanceof byte[] bytes))throw new IllegalArgumentException("deepHash byte[]/List expected");return sha384(concat(sha384(utf8("blob"+bytes.length)),sha384(bytes)));
}
private static void addTag(List<Map<String,String>> json,List<List<byte[]>> raw,String name,String value){byte[]n=utf8(name),v=utf8(value);Map<String,String>m=new LinkedHashMap<>();m.put("name",b64(n));m.put("value",b64(v));json.add(m);raw.add(List.of(n,v));}
private static String required(JsonNode n,String f){String s=n==null?"":n.path(f).asText("").trim();if(s.isBlank())throw new IllegalStateException("Arweave JWK missing "+f);return s;}
private static BigInteger big(String s){return new BigInteger(1,b64Decode(s));}
private static String trimGateway(String s){return(s==null?"https://arweave.net":s.trim()).replaceAll("/+$","");}
private static byte[] utf8(String s){return String.valueOf(s==null?"":s).getBytes(StandardCharsets.UTF_8);}
private static byte[] b64Decode(String s){return B64D.decode(s);}private static String b64(byte[]b){return B64.encodeToString(b);}
private static byte[] sha256(byte[]b)throws GeneralSecurityException{return MessageDigest.getInstance("SHA-256").digest(b);}private static byte[] sha384(byte[]b)throws GeneralSecurityException{return MessageDigest.getInstance("SHA-384").digest(b);}
private static byte[] concat(byte[]...a){int n=0;for(byte[]x:a)n=Math.addExact(n,x.length);byte[]o=new byte[n];int p=0;for(byte[]x:a){System.arraycopy(x,0,o,p,x.length);p+=x.length;}return o;}
private static String safe(String s){s=String.valueOf(s==null?"":s).replace('\n',' ').replace('\r',' ').trim();return s.length()<=250?s:s.substring(0,250)+"...";}
private record Wallet(String owner,String address,PrivateKey privateKey){}
}
@@ -1,206 +0,0 @@
package server.archive;
import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.*;
/**
* Arweave v2 data Merkle tree/proofs. Алгоритм повторяет arweave-js merkle.ts.
*/
final class ArweaveMerkle {
static final int MAX_CHUNK_SIZE = 256 * 1024;
static final int MIN_CHUNK_SIZE = 32 * 1024;
record Chunk(byte[] dataHash, long minByteRange, long maxByteRange) {
long size() { return maxByteRange - minByteRange; }
}
record Proof(long offset, byte[] proof) {}
record Prepared(byte[] dataRoot, List<Chunk> chunks, List<Proof> proofs) {}
private sealed interface Node permits Leaf, Branch {
byte[] id();
long maxByteRange();
}
private record Leaf(byte[] id, byte[] dataHash, long minByteRange, long maxByteRange) implements Node {}
private record Branch(byte[] id, long byteRange, long maxByteRange, Node left, Node right) implements Node {}
private ArweaveMerkle() {}
static Prepared prepare(byte[] data) throws IOException {
if (data == null || data.length == 0) throw new IOException("Arweave data is empty");
List<Chunk> chunks = chunkBytes(data);
List<Node> leaves = new ArrayList<>(chunks.size());
for (Chunk c : chunks) {
byte[] id = sha256(concat(sha256(c.dataHash()), sha256(note(c.maxByteRange()))));
leaves.add(new Leaf(id, c.dataHash(), c.minByteRange(), c.maxByteRange()));
}
Node root = buildLayers(leaves);
List<Proof> proofs = new ArrayList<>();
resolveProofs(root, new byte[0], proofs);
if (!chunks.isEmpty() && chunks.get(chunks.size() - 1).size() == 0) {
chunks = new ArrayList<>(chunks);
chunks.remove(chunks.size() - 1);
proofs.remove(proofs.size() - 1);
}
if (chunks.size() != proofs.size()) throw new IOException("Arweave Merkle: chunks/proofs mismatch");
return new Prepared(root.id(), List.copyOf(chunks), List.copyOf(proofs));
}
private static List<Chunk> chunkBytes(byte[] data) {
List<Chunk> out = new ArrayList<>();
long remaining = data.length;
long cursor = 0;
int p = 0;
while (remaining >= MAX_CHUNK_SIZE) {
long chunkSize = MAX_CHUNK_SIZE;
long next = remaining - MAX_CHUNK_SIZE;
if (next > 0 && next < MIN_CHUNK_SIZE) chunkSize = (remaining + 1) / 2;
byte[] chunk = Arrays.copyOfRange(data, p, p + (int) chunkSize);
out.add(new Chunk(sha256(chunk), cursor, cursor + chunkSize));
p += (int) chunkSize;
cursor += chunkSize;
remaining -= chunkSize;
}
byte[] rest = Arrays.copyOfRange(data, p, p + (int) remaining);
out.add(new Chunk(sha256(rest), cursor, cursor + remaining));
return out;
}
static byte[] readChunk(byte[] data, Chunk c) throws IOException {
long len = c.size();
if (data == null || len < 0 || len > Integer.MAX_VALUE || c.minByteRange() < 0 || c.maxByteRange() > data.length) {
throw new IOException("Invalid Arweave chunk range");
}
return Arrays.copyOfRange(data, (int) c.minByteRange(), (int) c.maxByteRange());
}
static Prepared prepare(Path file) throws IOException {
long fileSize = Files.size(file);
List<Chunk> chunks = chunkFile(file, fileSize);
List<Node> leaves = new ArrayList<>(chunks.size());
for (Chunk c : chunks) {
byte[] id = sha256(concat(sha256(c.dataHash()), sha256(note(c.maxByteRange()))));
leaves.add(new Leaf(id, c.dataHash(), c.minByteRange(), c.maxByteRange()));
}
if (leaves.isEmpty()) throw new IOException("Arweave Merkle: нет leaves");
Node root = buildLayers(leaves);
List<Proof> proofs = new ArrayList<>();
resolveProofs(root, new byte[0], proofs);
// arweave-js строит root вместе с нулевым последним chunk при точном кратном 256KiB,
// но сам нулевой chunk/proof не загружает.
if (!chunks.isEmpty() && chunks.get(chunks.size() - 1).size() == 0) {
chunks = new ArrayList<>(chunks);
chunks.remove(chunks.size() - 1);
proofs.remove(proofs.size() - 1);
}
if (chunks.size() != proofs.size()) throw new IOException("Arweave Merkle: chunks/proofs mismatch");
return new Prepared(root.id(), List.copyOf(chunks), List.copyOf(proofs));
}
private static List<Chunk> chunkFile(Path file, long fileSize) throws IOException {
List<Chunk> out = new ArrayList<>();
long remaining = fileSize;
long cursor = 0;
try (InputStream in = new BufferedInputStream(Files.newInputStream(file))) {
while (remaining >= MAX_CHUNK_SIZE) {
long chunkSize = MAX_CHUNK_SIZE;
long next = remaining - MAX_CHUNK_SIZE;
if (next > 0 && next < MIN_CHUNK_SIZE) {
chunkSize = (remaining + 1) / 2;
}
byte[] data = readExact(in, (int)chunkSize);
out.add(new Chunk(sha256(data), cursor, cursor + chunkSize));
cursor += chunkSize;
remaining -= chunkSize;
}
byte[] rest = readExact(in, (int)remaining);
out.add(new Chunk(sha256(rest), cursor, cursor + remaining));
}
return out;
}
private static Node buildLayers(List<Node> nodes) {
if (nodes.size() < 2) return nodes.get(0);
List<Node> next = new ArrayList<>((nodes.size() + 1) / 2);
for (int i = 0; i < nodes.size(); i += 2) {
Node left = nodes.get(i);
Node right = i + 1 < nodes.size() ? nodes.get(i + 1) : null;
if (right == null) {
next.add(left);
continue;
}
long byteRange = left.maxByteRange();
byte[] id = sha256(concat(
sha256(left.id()),
sha256(right.id()),
sha256(note(byteRange))
));
next.add(new Branch(id, byteRange, right.maxByteRange(), left, right));
}
return buildLayers(next);
}
private static void resolveProofs(Node node, byte[] prefix, List<Proof> out) {
if (node instanceof Leaf leaf) {
out.add(new Proof(leaf.maxByteRange() - 1,
concat(prefix, leaf.dataHash(), note(leaf.maxByteRange()))));
return;
}
Branch b = (Branch) node;
byte[] partial = concat(prefix, b.left().id(), b.right().id(), note(b.byteRange()));
resolveProofs(b.left(), partial, out);
resolveProofs(b.right(), partial, out);
}
static byte[] readChunk(Path file, Chunk c) throws IOException {
long len = c.size();
if (len < 0 || len > Integer.MAX_VALUE) throw new IOException("Некорректный Arweave chunk size: " + len);
try (RandomAccessFile raf = new RandomAccessFile(file.toFile(), "r")) {
raf.seek(c.minByteRange());
byte[] data = new byte[(int)len];
raf.readFully(data);
return data;
}
}
private static byte[] readExact(InputStream in, int len) throws IOException {
byte[] out = new byte[len];
int pos = 0;
while (pos < len) {
int n = in.read(out, pos, len - pos);
if (n < 0) throw new EOFException("Неожиданный EOF");
pos += n;
}
return out;
}
private static byte[] note(long value) {
if (value < 0) throw new IllegalArgumentException("negative note");
byte[] out = new byte[32];
long v = value;
for (int i = 31; i >= 0 && v != 0; i--) {
out[i] = (byte)(v & 0xff);
v >>>= 8;
}
return out;
}
private static byte[] sha256(byte[] data) {
try { return MessageDigest.getInstance("SHA-256").digest(data); }
catch (NoSuchAlgorithmException e) { throw new IllegalStateException(e); }
}
private static byte[] concat(byte[]... arrays) {
int len = 0;
for (byte[] a : arrays) len = Math.addExact(len, a.length);
byte[] out = new byte[len];
int p=0;
for (byte[] a : arrays) { System.arraycopy(a,0,out,p,a.length); p+=a.length; }
return out;
}
}
@@ -1,106 +0,0 @@
package server.archive;
import blockchain.Ans104DataItem;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.security.MessageDigest;
import java.time.Duration;
import java.util.Arrays;
import java.util.Base64;
import java.util.Objects;
/** Uploads an already user-signed ANS-104 DataItem to Turbo without modifying it. */
public final class TurboDataItemUploader {
private static final ObjectMapper MAPPER = new ObjectMapper();
private static final Base64.Encoder B64URL = Base64.getUrlEncoder().withoutPadding();
private static final Base64.Decoder B64URL_DECODER = Base64.getUrlDecoder();
public record UploadResult(String dataItemId, String owner) {}
private final ArweaveBlocksConfig cfg;
private final HttpClient http = HttpClient.newBuilder()
.connectTimeout(Duration.ofSeconds(20))
.followRedirects(HttpClient.Redirect.NORMAL)
.build();
private volatile String resolvedPaidByAddress;
public TurboDataItemUploader(ArweaveBlocksConfig cfg) {
this.cfg = Objects.requireNonNull(cfg);
}
public UploadResult upload(byte[] rawDataItem, byte[] expectedId32) throws Exception {
if (rawDataItem == null || rawDataItem.length == 0) throw new IllegalArgumentException("Turbo DataItem is empty");
Ans104DataItem item = new Ans104DataItem(rawDataItem);
if (!item.verifySignature()) throw new IllegalArgumentException("Turbo DataItem has bad ANS-104 signature");
if (expectedId32 != null && !Arrays.equals(item.id32(), expectedId32)) {
throw new IllegalArgumentException("Turbo DataItem id does not match blocks.data_item_id");
}
String expectedId = B64URL.encodeToString(item.id32());
HttpRequest.Builder request = HttpRequest.newBuilder(URI.create(cfg.turboUploadUrl()))
.timeout(Duration.ofMinutes(2))
.header("Content-Type", "application/octet-stream")
.header("Accept", "application/json")
.POST(HttpRequest.BodyPublishers.ofByteArray(rawDataItem));
String paidBy = paidByAddress();
if (paidBy != null) request.header("x-paid-by", paidBy);
HttpResponse<String> response = http.send(request.build(), HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
String body = response.body() == null ? "" : response.body().trim();
if (response.statusCode() == 409 && body.toLowerCase().contains("data item exists")) {
return new UploadResult(expectedId, B64URL.encodeToString(item.owner32()));
}
if (response.statusCode() < 200 || response.statusCode() >= 300) {
String hint = response.statusCode() == 402
? " (Turbo payment required: check server credits / Credit Share Approval / x-paid-by)"
: "";
throw new IOException("Turbo HTTP " + response.statusCode() + hint + ": " + safe(body));
}
if (body.isBlank()) return new UploadResult(expectedId, B64URL.encodeToString(item.owner32()));
JsonNode json;
try { json = MAPPER.readTree(body); }
catch (Exception ignored) { return new UploadResult(expectedId, B64URL.encodeToString(item.owner32())); }
String returnedId = json.path("id").asText("").trim();
if (!returnedId.isBlank() && !returnedId.equals(expectedId)) {
throw new IOException("Turbo returned another DataItem id: expected=" + expectedId + " got=" + returnedId);
}
return new UploadResult(expectedId, json.path("owner").asText(""));
}
/**
* x-paid-by contains the payer's public native address, never the private key.
* A configured Arweave JWK is used only to derive that public address.
*/
private String paidByAddress() throws Exception {
if (resolvedPaidByAddress != null) return resolvedPaidByAddress.isBlank() ? null : resolvedPaidByAddress;
synchronized (this) {
if (resolvedPaidByAddress != null) return resolvedPaidByAddress.isBlank() ? null : resolvedPaidByAddress;
String explicit = cfg.turboPaidByAddress();
if (explicit != null && !explicit.isBlank()) return resolvedPaidByAddress = explicit.trim();
if (cfg.turboWalletJwkPath() == null) {
resolvedPaidByAddress = "";
return null;
}
JsonNode jwk = MAPPER.readTree(Files.readString(cfg.turboWalletJwkPath(), StandardCharsets.UTF_8));
String modulus = jwk.path("n").asText("").trim();
if (modulus.isBlank()) throw new IllegalStateException("Turbo payer JWK missing n");
byte[] owner = B64URL_DECODER.decode(modulus);
resolvedPaidByAddress = B64URL.encodeToString(MessageDigest.getInstance("SHA-256").digest(owner));
return resolvedPaidByAddress;
}
}
private static String safe(String value) {
String v = value == null ? "" : value.replace('\n',' ').replace('\r',' ').trim();
return v.length() <= 500 ? v : v.substring(0, 500);
}
}
@@ -1,50 +0,0 @@
package server.archive.registration;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HashSet;
import java.util.Locale;
import java.util.Set;
import java.util.regex.Pattern;
/** Список разрешённых доменов для бесплатной регистрации; читается при старте Java-сервера. */
public final class AllowedEmailDomains {
// Обычные ASCII-домены (в том числе punycode), без масок, пробелов и URL.
private static final Pattern DOMAIN = Pattern.compile(
"(?=.{1,253}$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)+");
private final Set<String> domains;
private AllowedEmailDomains(Set<String> domains) {
this.domains = Set.copyOf(domains);
}
/** Ошибки чтения, пустой или неверный список — ошибка запуска регистрации (fail-closed). */
public static AllowedEmailDomains load(Path file) throws IOException {
if (!Files.isRegularFile(file))
throw new IOException("Email domain allowlist is missing: " + file.toAbsolutePath());
Set<String> result = new HashSet<>();
int lineNumber = 0;
for (String line : Files.readAllLines(file, StandardCharsets.UTF_8)) {
lineNumber++;
String domain = line.strip().toLowerCase(Locale.ROOT);
if (domain.isEmpty() || domain.startsWith("#")) continue;
if (!DOMAIN.matcher(domain).matches())
throw new IOException("Invalid allowed email domain at " + file + ":" + lineNumber);
result.add(domain);
}
if (result.isEmpty())
throw new IOException("Email domain allowlist is empty: " + file.toAbsolutePath());
return new AllowedEmailDomains(result);
}
/** Сопоставление строго по части после одного символа @, без wildcard и суффиксов. */
public boolean permits(String email) {
if (email == null) return false;
String value = email.strip().toLowerCase(Locale.ROOT);
int at = value.indexOf('@');
if (at <= 0 || at != value.lastIndexOf('@')) return false;
return domains.contains(value.substring(at + 1));
}
}
@@ -1,140 +0,0 @@
package server.archive.registration;
import server.archive.ArweaveBlocksConfig;
import server.archive.TurboDataItemUploader;
import server.logic.ws_protocol.JSON.handlers.registration.RegistrationApiBridge;
import server.logic.ws_protocol.JSON.handlers.registration.Net_Registration_Request;
import shine.db.DbController;
import utils.config.AppConfig;
import javax.sql.DataSource;
import java.io.PrintWriter;
import java.nio.file.Path;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.Base64;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Logger;
/** Единственная точка подключения API без циклической зависимости Gradle-модулей. */
public final class FreeRegistrationApiBootstrap {
private static volatile FreeRegistrationWorkflow workflow;
private static volatile LocalRegistrarSigner signer;
private FreeRegistrationApiBootstrap() {}
public static synchronized void startOrThrow() throws Exception {
if (workflow != null) return;
AppConfig cfg=AppConfig.getInstance();
LocalRegistrarSigner newSigner=null;
FreeRegistrationIssuer issuer=null;
FreeRegistrationPublisher publisher=null;
RegistrationEmailSender emailSender=null;
AllowedEmailDomains allowedEmailDomains=null;
if (cfg.getBoolean("freeRegistration.enabled",false)) {
String domainsFile = cfg.getStringOrEmpty("freeRegistration.email.allowedDomainsFile");
if (domainsFile.isBlank()) domainsFile = "allowed-email-domains.txt";
// Относительный путь — от WorkingDirectory процесса Java.
allowedEmailDomains = AllowedEmailDomains.load(Path.of(domainsFile));
boolean allowEmailReuse=cfg.getBoolean("freeRegistration.email.allowReuse",false);
// Не выводить seed/path в журнал ни при успешном старте, ни при ошибке.
ArweaveBlocksConfig transport=ArweaveBlocksConfig.load();
if(transport.publishMode()!=ArweaveBlocksConfig.PublishMode.TURBO)
throw new IllegalStateException("Free registration requires Turbo transport");
newSigner=LocalRegistrarSigner.fromConfig(cfg);
issuer=new FreeRegistrationIssuer(dbSource(),newSigner,allowEmailReuse);
publisher=new FreeRegistrationPublisher(issuer,new TurboDataItemUploader(transport),
new VerifiedFreeRegistrationImporter(allowEmailReuse));
// Секрет берём ТОЛЬКО из окружения, не из файлов репозитория.
String resendKey=System.getenv("RESEND_API_KEY");
if(resendKey==null || resendKey.isBlank())
resendKey=cfg.getStringOrEmpty("freeRegistration.email.apiKey");
emailSender=new ResendRegistrationEmailSender(resendKey,
cfg.getStringOrEmpty("freeRegistration.email.from").isBlank()
? "SHiNE <noreply@shineup.me>"
: cfg.getStringOrEmpty("freeRegistration.email.from"));
}
FreeRegistrationWorkflow newWorkflow=new FreeRegistrationWorkflow(issuer,publisher,emailSender,
cfg.getBoolean("freeRegistration.email.allowTestCode",false),
cfg.getBoolean("freeRegistration.email.allowReuse",false), allowedEmailDomains);
RegistrationApiBridge.install((op,req)->dispatch(newWorkflow,op,req));
signer=newSigner; workflow=newWorkflow;
}
public static synchronized void close() {
RegistrationApiBridge.uninstall();
workflow=null;
if(signer!=null) signer.close();
signer=null;
}
public static Map<String,Object> dispatch(FreeRegistrationWorkflow w, String op,Net_Registration_Request req) throws Exception {
Map<String,Object> out=new LinkedHashMap<>();
switch(op) {
case "GetNamespaces" -> {
out.put("namespaces",w.listNamespaces().stream().map(ns->Map.of(
"name",ns.namespace(), "type",ns.type(), "minLocalLength",ns.minLoginLength(),
"registrationFeeLamports",ns.priceLamports(), "currencyCode",ns.currencyCode(), "defaultServerLogin",ns.serverLogin()==null?"":ns.serverLogin()
)).toList());
}
case "CheckRegistrationLogin" -> {
var info=w.checkLogin(req.getFullLogin());
out.put("loginAvailable",info.loginAvailable());
out.put("namespaceType",info.namespaceType());
out.put("minLocalLength",info.minLocalLength());
out.put("registrationFeeLamports",info.registrationFeeLamports());
out.put("currencyCode",info.currencyCode());
}
case "CheckRegistrationEmail" -> {
var check=w.checkEmail(req.getEmail());
out.put("emailAvailable",check.emailAvailable());
out.put("emailStatus",check.emailStatus());
}
case "StartFreeRegistration" -> {
var state=w.start(req.getFullLogin(),decodeKey(req.getRootPublicKeyB64()),
decodeKey(req.getBlockchainPublicKeyB64()),decodeKey(req.getClientPublicKeyB64()),req.getEmail());
out.put("challengeId",state.challengeId()); out.put("expiresAtMs",state.expiresAtMs());
}
case "ConfirmFreeRegistration" -> {
var value=w.confirm(req.getChallengeId(),req.getCode());
out.put("fullLogin",value.fullLogin());out.put("dataItemId",value.dataItemId());
out.put("publicationStatus",value.state());out.put("chainConfirmed",false);
}
case "GetRegistrationStatus" -> {
var value=w.getStatus(req.getFullLogin());
out.put("registrationStatus",value.status());
out.put("dataItemId",value.dataItemId()==null?"":value.dataItemId());
out.put("publicationStatus",value.publicationStatus()==null?"":value.publicationStatus());
// Публичная историческая часть сертификата для бесплатного → Solana upgrade.
if("FREE_CERT".equals(value.status())) {
out.put("innerSignature64B64",value.innerSignature64B64()==null?"":value.innerSignature64B64());
out.put("rootPublicKey",value.rootPublicKey()==null?"":value.rootPublicKey());
out.put("blockchainPublicKey",value.blockchainPublicKey()==null?"":value.blockchainPublicKey());
out.put("clientPublicKey",value.clientPublicKey()==null?"":value.clientPublicKey());
out.put("defaultServerLogin",value.defaultServerLogin()==null?"":value.defaultServerLogin());
}
}
default -> throw new IllegalArgumentException("Unknown registration operation");
}
return out;
}
private static byte[] decodeKey(String base64) {
if(base64==null || base64.length()>64)throw new IllegalArgumentException("Invalid public key");
byte[] decoded=Base64.getDecoder().decode(base64);
if(decoded.length!=32)throw new IllegalArgumentException("Invalid public key length");
return decoded;
}
private static DataSource dbSource() {
return new DataSource() {
@Override public Connection getConnection() throws SQLException {return DbController.getInstance().getConnection();}
@Override public Connection getConnection(String u,String p) throws SQLException {throw new SQLFeatureNotSupportedException();}
@Override public PrintWriter getLogWriter(){return null;}
@Override public void setLogWriter(PrintWriter p){}
@Override public void setLoginTimeout(int t){}
@Override public int getLoginTimeout(){return 0;}
@Override public Logger getParentLogger(){return Logger.getGlobal();}
@Override public <T> T unwrap(Class<T> type) throws SQLException {throw new SQLFeatureNotSupportedException();}
@Override public boolean isWrapperFor(Class<?> type){return false;}
};
}
}
@@ -1,115 +0,0 @@
package server.archive.registration;
import blockchain.Ans104DataItem;
import blockchain.ShineProtocolTags;
import utils.crypto.Ed25519Util;
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.text.Normalizer;
import java.util.Arrays;
import java.util.Base64;
import java.util.List;
import java.util.Locale;
/** Строгое формирование и проверка двух подписей нового независимого DataItem `t=reg`. */
public final class FreeRegistrationCertificateV1 {
private static final byte[] DOMAIN = "SHiNE_FREE_REG_V1\0".getBytes(StandardCharsets.UTF_8);
private static final List<Ans104DataItem.Tag> TAGS = List.of(
new Ans104DataItem.Tag(ShineProtocolTags.APP_TAG_NAME, ShineProtocolTags.APP_TAG_VALUE),
new Ans104DataItem.Tag("t", "reg"),
new Ans104DataItem.Tag("Protocol", "SHiNE-Free-Registration-V1"));
public record Verified(String login, byte[] rootKey, byte[] blockchainKey,
byte[] clientKey, byte[] innerSignature,
byte[] emailSha256, byte[] owner32, String idBase64Url) {}
private FreeRegistrationCertificateV1() {}
public static String validateLogin(String login) {
if (login == null || !login.matches("[A-Za-z0-9_]+@[a-z0-9_]+") || login.length() > 30)
throw new IllegalArgumentException("Full login must use ASCII letters (any local-part case), lowercase namespace, <= 30 bytes");
return login;
}
public static byte[] identityFields(String login, byte[] root32, byte[] blockchain32, byte[] client32) {
byte[] name = validateLogin(login).getBytes(StandardCharsets.UTF_8);
require32(root32); require32(blockchain32); require32(client32);
ByteArrayOutputStream out = new ByteArrayOutputStream();
out.write(1); out.write(0); out.write(name.length); out.writeBytes(name);
out.writeBytes(root32); out.writeBytes(blockchain32); out.writeBytes(client32);
return out.toByteArray();
}
public static byte[] innerMessage(byte[] identity) {
ByteArrayOutputStream out = new ByteArrayOutputStream();
out.writeBytes(DOMAIN); out.writeBytes(identity);
return out.toByteArray();
}
public static String normalizeEmail(String email) {
if (email == null) throw new IllegalArgumentException("Email is required");
String value = Normalizer.normalize(email.strip(), Normalizer.Form.NFC).toLowerCase(Locale.ROOT);
if (value.isBlank() || value.indexOf('@') < 1 || value.contains(" "))
throw new IllegalArgumentException("Invalid email");
return value;
}
public static byte[] emailHash(String email) {
return sha256(normalizeEmail(email).getBytes(StandardCharsets.UTF_8));
}
public static byte[] issue(String login, byte[] root32, byte[] blockchain32,
byte[] client32, String email, RegistrarSigner signer) {
byte[] fields = identityFields(login, root32, blockchain32, client32);
byte[] inner = signer.sign(innerMessage(fields));
if (inner.length != 64) throw new IllegalStateException("Invalid inner signature length");
ByteArrayOutputStream payload = new ByteArrayOutputStream();
payload.writeBytes(fields);
payload.writeBytes(inner);
payload.writeBytes(emailHash(email));
byte[] data = payload.toByteArray();
byte[] owner = signer.publicKey32();
require32(owner);
byte[] outer = signer.sign(Ans104DataItem.buildSigningMessage(owner, TAGS, data));
byte[] raw = Ans104DataItem.serializeEd25519(outer, owner, TAGS, data);
verify(raw, owner);
return raw;
}
public static Verified verify(byte[] signedDataItem, byte[] registrarPublicKey32) {
require32(registrarPublicKey32);
Ans104DataItem item = new Ans104DataItem(signedDataItem);
if (!item.ownerEquals(registrarPublicKey32) || !item.verifySignature())
throw new IllegalArgumentException("Invalid outer ANS-104 registrar signature");
if (!item.tags().equals(TAGS) || item.target().length != 0 || item.anchor().length != 0)
throw new IllegalArgumentException("Unexpected registration tags/target/anchor");
byte[] data = item.data();
if (data.length < 3 + 96 + 64 + 32 || data[0] != 1 || data[1] != 0)
throw new IllegalArgumentException("Invalid certificate version/length");
int len = data[2] & 0xff;
if (data.length != 3 + len + 96 + 64 + 32)
throw new IllegalArgumentException("Invalid certificate byte length");
String login = validateLogin(new String(data, 3, len, StandardCharsets.UTF_8));
int offset = 3 + len;
byte[] root = Arrays.copyOfRange(data, offset, offset+32); offset += 32;
byte[] blockchain = Arrays.copyOfRange(data, offset, offset+32); offset += 32;
byte[] client = Arrays.copyOfRange(data, offset, offset+32); offset += 32;
byte[] innerSig = Arrays.copyOfRange(data, offset, offset+64); offset += 64;
byte[] emailSha = Arrays.copyOfRange(data, offset, offset+32);
byte[] fields = Arrays.copyOfRange(data, 0, 3 + len + 96);
if (!Ed25519Util.verify(innerMessage(fields), innerSig, registrarPublicKey32))
throw new IllegalArgumentException("Invalid inner certificate signature");
return new Verified(login, root, blockchain, client, innerSig, emailSha,
item.owner32(), Base64.getUrlEncoder().withoutPadding().encodeToString(item.id32()));
}
private static void require32(byte[] key) {
if (key == null || key.length != 32) throw new IllegalArgumentException("Expected 32-byte public key");
}
private static byte[] sha256(byte[] data) {
try { return MessageDigest.getInstance("SHA-256").digest(data); }
catch (Exception e) { throw new IllegalStateException("SHA-256 unavailable", e); }
}
}
@@ -1,74 +0,0 @@
package server.archive.registration;
import sync.util.Base58Util;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Arrays;
/** Выдача (без публикации). Stage 8 публикует через Turbo и импортирует тот же raw DataItem. */
public final class FreeRegistrationIssuer {
private final DataSource db;
private final RegistrarSigner signer;
private final boolean allowEmailReuse;
public FreeRegistrationIssuer(DataSource db, RegistrarSigner signer) {
this(db, signer, false);
}
public FreeRegistrationIssuer(DataSource db, RegistrarSigner signer, boolean allowEmailReuse) {
this.db = java.util.Objects.requireNonNull(db);
this.signer = java.util.Objects.requireNonNull(signer);
this.allowEmailReuse = allowEmailReuse;
}
/** Выдаётся только после успешной проверки challenge в FreeRegistrationWorkflow. */
synchronized byte[] issue(String fullLogin, byte[] root32, byte[] blockchain32,
byte[] client32, String email) throws Exception {
FreeRegistrationCertificateV1.validateLogin(fullLogin);
String namespace = fullLogin.substring(fullLogin.indexOf('@') + 1);
byte[] expectedEmail = FreeRegistrationCertificateV1.emailHash(email);
try (Connection conn = db.getConnection()) {
conn.setReadOnly(true);
String sql = """
SELECT namespace_type, min_localpart_len, registrar_pubkey, default_server_login
FROM shine_namespace_current WHERE namespace = ?
""";
try (PreparedStatement statement = conn.prepareStatement(sql)) {
statement.setString(1, namespace);
try (ResultSet rs = statement.executeQuery()) {
if (!rs.next() || rs.getInt("namespace_type") != 2 ||
fullLogin.indexOf('@') < rs.getInt("min_localpart_len"))
throw new IllegalArgumentException("Free namespace is unavailable");
byte[] nsPub = Base58Util.decode(rs.getString("registrar_pubkey"));
if (!Arrays.equals(nsPub, signer.publicKey32()))
throw new IllegalStateException("Registrar public key does not match on-chain namespace");
String server = rs.getString("default_server_login");
if (server == null || server.isBlank())
throw new IllegalStateException("Free namespace server is not configured");
}
}
try (PreparedStatement ps = conn.prepareStatement(
"SELECT 1 FROM user_identity_current WHERE normalized_login = ?")) {
ps.setString(1, fullLogin.toLowerCase(java.util.Locale.ROOT));
try (ResultSet rs = ps.executeQuery()) {
if (rs.next()) throw new IllegalArgumentException("Login is already registered");
}
}
if (!allowEmailReuse) {
try (PreparedStatement ps = conn.prepareStatement(
"SELECT 1 FROM free_registration_certificate WHERE email_sha256 = ?")) {
ps.setBytes(1, expectedEmail);
try (ResultSet rs = ps.executeQuery()) {
if (rs.next()) throw new IllegalArgumentException("Email hash already registered");
}
}
}
}
// Это только подписанный артефакт, не активная регистрация. Перед Turbo
// и локальным импортом обязательно повторять уникальность в транзакции БД.
return FreeRegistrationCertificateV1.issue(fullLogin, root32, blockchain32, client32, email, signer);
}
}
@@ -1,30 +0,0 @@
package server.archive.registration;
import server.archive.TurboDataItemUploader;
import blockchain.Ans104DataItem;
/** Отдельный транспорт регистрации. Публикация не является пользовательским AddBlock. */
public final class FreeRegistrationPublisher {
private final FreeRegistrationIssuer issuer;
private final TurboDataItemUploader uploader;
private final VerifiedFreeRegistrationImporter importer;
public FreeRegistrationPublisher(FreeRegistrationIssuer issuer, TurboDataItemUploader uploader,
VerifiedFreeRegistrationImporter importer) {
this.issuer = java.util.Objects.requireNonNull(issuer);
this.uploader = java.util.Objects.requireNonNull(uploader);
this.importer = java.util.Objects.requireNonNull(importer);
}
/** Для повтора ПОСЛЕ потери ACK передавайте точно те же signedBytes. */
public VerifiedFreeRegistrationImporter.ImportResult publishSigned(byte[] signedBytes) throws Exception {
Ans104DataItem parsed = new Ans104DataItem(signedBytes);
importer.validateForUpload(signedBytes); // строго до HTTP/Turbo списания кредитов
// Импорт на этой точке вызовет полную проверку обеих подписей и namespace
// ПОСЛЕ успешного ACK Turbo, а не до окончательного подтверждения Arweave.
TurboDataItemUploader.UploadResult acknowledged = uploader.upload(signedBytes, parsed.id32());
String expectedId = java.util.Base64.getUrlEncoder().withoutPadding().encodeToString(parsed.id32());
if (!expectedId.equals(acknowledged.dataItemId()))
throw new IllegalStateException("Unexpected Turbo DataItem id");
return importer.importSigned(signedBytes, VerifiedFreeRegistrationImporter.Provenance.TURBO_ACCEPTED);
}
}
@@ -1,251 +0,0 @@
package server.archive.registration;
import shine.db.DbController;
import java.security.SecureRandom;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.time.Duration;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Base64;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/** Внутренний state machine публичных операций регистрации v2. */
public final class FreeRegistrationWorkflow {
public record NamespaceInfo(String namespace, int type, int minLoginLength, String priceLamports, int currencyCode, String serverLogin) {}
public record Availability(boolean nameFree, boolean emailHashFree) {}
public record LoginCheck(boolean loginAvailable, int namespaceType, int minLocalLength, String registrationFeeLamports, int currencyCode) {}
public record EmailCheck(boolean emailAvailable, String emailStatus) {}
public record Started(String challengeId, long expiresAtMs) {}
public record Completed(String fullLogin, String dataItemId, String state, boolean alreadyImported) {}
public record State(String status, String dataItemId, String publicationStatus, String innerSignature64B64,
String rootPublicKey, String blockchainPublicKey, String clientPublicKey,
String defaultServerLogin) {}
private record Draft(String login, byte[] root, byte[] blockchain, byte[] client, String email,
long expiresAtMs, byte[] codeHash, int attempts, boolean delivered,
boolean verified, byte[] signedBytes) {
Draft update(int attempts, boolean delivered, boolean verified, byte[] signedBytes) {
return new Draft(login, root, blockchain, client, email, expiresAtMs,
codeHash, attempts, delivered, verified, signedBytes);
}
}
private final Map<String, Draft> pending = new ConcurrentHashMap<>();
// Не храним в БД почтовые адреса, пока регистрация не завершилась.
private final Map<String, Long> recentEmails = new HashMap<>();
private final Map<String, Long> recentLogins = new HashMap<>();
private final java.util.ArrayDeque<Long> globalSendTimes = new java.util.ArrayDeque<>();
private static final long TTL_MS = Duration.ofHours(1).toMillis();
private static final long EMAIL_COOLDOWN_MS = Duration.ofMinutes(1).toMillis();
private static final long GLOBAL_WINDOW_MS = Duration.ofHours(1).toMillis();
private static final int MAX_EMAILS_PER_HOUR = 60;
private static final int MAX_ATTEMPTS = 5;
private static final int MAX_PENDING = 512;
private static final SecureRandom RANDOM = new SecureRandom();
private final FreeRegistrationIssuer issuer;
private final FreeRegistrationPublisher publisher;
private final RegistrationEmailSender emailSender;
private final boolean allowTestCode;
private final boolean allowEmailReuse;
private final AllowedEmailDomains allowedEmailDomains;
public FreeRegistrationWorkflow(FreeRegistrationIssuer issuer, FreeRegistrationPublisher publisher,
RegistrationEmailSender emailSender, boolean allowTestCode, boolean allowEmailReuse,
AllowedEmailDomains allowedEmailDomains) {
if ((issuer == null) != (publisher == null)) throw new IllegalArgumentException("Signer/publisher mismatch");
if (issuer != null && emailSender == null) throw new IllegalArgumentException("Email sender is required");
if (emailSender != null && allowedEmailDomains == null)
throw new IllegalArgumentException("Allowed email domain list is required");
this.allowedEmailDomains = allowedEmailDomains;
this.issuer = issuer;
this.publisher = publisher;
this.emailSender = emailSender;
this.allowTestCode = allowTestCode;
this.allowEmailReuse = allowEmailReuse;
}
public FreeRegistrationWorkflow(FreeRegistrationIssuer issuer, FreeRegistrationPublisher publisher,
RegistrationEmailSender emailSender, boolean allowTestCode, boolean allowEmailReuse) {
this(issuer, publisher, emailSender, allowTestCode, allowEmailReuse,
emailSender == null ? null : loadDefaultEmailDomains());
}
private static AllowedEmailDomains loadDefaultEmailDomains() {
try {
return AllowedEmailDomains.load(java.nio.file.Path.of("allowed-email-domains.txt"));
} catch (java.io.IOException e) {
throw new IllegalStateException("Cannot load allowed email domains", e);
}
}
public FreeRegistrationWorkflow(FreeRegistrationIssuer issuer, FreeRegistrationPublisher publisher,
RegistrationEmailSender emailSender, boolean allowTestCode) {
this(issuer, publisher, emailSender, allowTestCode, false);
}
public FreeRegistrationWorkflow(FreeRegistrationIssuer issuer, FreeRegistrationPublisher publisher,
RegistrationEmailSender emailSender) {
this(issuer, publisher, emailSender, false);
}
public FreeRegistrationWorkflow(FreeRegistrationIssuer issuer, FreeRegistrationPublisher publisher) {
this(issuer, publisher, null);
}
public List<NamespaceInfo> listNamespaces() throws Exception {
List<NamespaceInfo> result = new ArrayList<>();
try (Connection c = DbController.getInstance().getConnection();
PreparedStatement ps = c.prepareStatement("""
SELECT namespace,namespace_type,min_localpart_len,registration_fee_lamports,currency_code,default_server_login
FROM shine_namespace_current ORDER BY namespace
"""); ResultSet rs = ps.executeQuery()) {
while (rs.next()) result.add(new NamespaceInfo(rs.getString(1),rs.getInt(2),rs.getInt(3),
rs.getString(4),rs.getInt(5),rs.getString(6)));
}
return List.copyOf(result);
}
public LoginCheck checkLogin(String login) throws Exception {
FreeRegistrationCertificateV1.validateLogin(login);
String namespace=login.substring(login.indexOf('@')+1);
try (Connection c=DbController.getInstance().getConnection()) {
int type, minimum, currencyCode; String fee;
try (PreparedStatement p=c.prepareStatement("SELECT namespace_type,min_localpart_len,registration_fee_lamports,currency_code FROM shine_namespace_current WHERE namespace=?")) {
p.setString(1,namespace);
try (ResultSet rs=p.executeQuery()) {
if (!rs.next()) throw new IllegalArgumentException("Namespace is unavailable");
type=rs.getInt(1); minimum=rs.getInt(2); fee=rs.getString(3); currencyCode=rs.getInt(4);
if (currencyCode != 1) throw new IllegalStateException("Unsupported namespace currency");
if (login.indexOf('@') < minimum) throw new IllegalArgumentException("Login shorter than namespace minimum");
}
}
try (PreparedStatement p=c.prepareStatement("SELECT 1 FROM user_identity_current WHERE normalized_login=?")) {
p.setString(1, login.toLowerCase(java.util.Locale.ROOT));
try (ResultSet rs=p.executeQuery()) { return new LoginCheck(!rs.next(),type,minimum,fee,currencyCode); }
}
}
}
public EmailCheck checkEmail(String email) throws Exception {
// До запроса к БД: отсутствие разрешения не должно раскрывать занятость email.
String normalizedEmail = FreeRegistrationCertificateV1.normalizeEmail(email);
if (allowedEmailDomains == null || !allowedEmailDomains.permits(normalizedEmail))
return new EmailCheck(false, "DOMAIN_NOT_ALLOWED");
byte[] hash=FreeRegistrationCertificateV1.emailHash(normalizedEmail);
if (allowEmailReuse) return new EmailCheck(true, "AVAILABLE");
try (Connection c=DbController.getInstance().getConnection();
PreparedStatement p=c.prepareStatement("SELECT 1 FROM free_registration_certificate WHERE email_sha256=?")) {
p.setBytes(1,hash);
try(ResultSet rs=p.executeQuery()) { return rs.next() ? new EmailCheck(false, "ALREADY_REGISTERED")
: new EmailCheck(true, "AVAILABLE"); }
}
}
/** Устаревший внутренний helper: внешний API использует две отдельные операции. */
public Availability availability(String login,String email) throws Exception {
return new Availability(checkLogin(login).loginAvailable(),checkEmail(email).emailAvailable());
}
public Started start(String login, byte[] root, byte[] blockchain, byte[] client, String email) throws Exception {
if (issuer == null || publisher == null || emailSender == null)
throw new IllegalStateException("Free registration is disabled");
FreeRegistrationCertificateV1.identityFields(login,root,blockchain,client);
LoginCheck checked = checkLogin(login);
if (checked.namespaceType()!=2 || !checked.loginAvailable())
throw new IllegalStateException("Login is unavailable");
if (!checkEmail(email).emailAvailable()) throw new IllegalStateException("Email is unavailable");
String cleanEmail=FreeRegistrationCertificateV1.normalizeEmail(email);
String normalizedLogin=login.toLowerCase(java.util.Locale.ROOT);
byte[] id=new byte[32]; RANDOM.nextBytes(id);
String challenge=Base64.getUrlEncoder().withoutPadding().encodeToString(id);
String code=RegistrationEmailCode.generate();
long now=System.currentTimeMillis();
long expires=now+TTL_MS;
Draft draft=new Draft(login,root.clone(),blockchain.clone(),client.clone(),cleanEmail,
expires,RegistrationEmailCode.hash(challenge,code),0,false,false,null);
synchronized (this) {
pending.entrySet().removeIf(e->e.getValue().expiresAtMs < now);
recentEmails.entrySet().removeIf(e->e.getValue() < now-TTL_MS);
recentLogins.entrySet().removeIf(e->e.getValue() < now-TTL_MS);
while(!globalSendTimes.isEmpty() && globalSendTimes.peekFirst() < now-GLOBAL_WINDOW_MS)
globalSendTimes.removeFirst();
if (pending.size() >= MAX_PENDING) throw new IllegalStateException("Too many pending registrations");
if (now-recentEmails.getOrDefault(cleanEmail,0L) < EMAIL_COOLDOWN_MS ||
now-recentLogins.getOrDefault(normalizedLogin,0L) < EMAIL_COOLDOWN_MS)
throw new IllegalStateException("Please wait before requesting another code");
if (globalSendTimes.size() >= MAX_EMAILS_PER_HOUR)
throw new IllegalStateException("Email verification temporarily limited");
recentEmails.put(cleanEmail,now);
recentLogins.put(normalizedLogin,now);
globalSendTimes.addLast(now);
pending.put(challenge,draft);
}
try {
// Не блокируем monitor workflow на время HTTP-запроса к Resend.
emailSender.sendVerificationCode(cleanEmail,code);
} catch (Exception e) {
synchronized (this) {
pending.remove(challenge);
recentEmails.remove(cleanEmail,now);
recentLogins.remove(normalizedLogin,now);
globalSendTimes.removeFirstOccurrence(now);
}
throw e;
}
synchronized (this) {
// Новый успешно отправленный код заменяет старые заявки на тот же login/email.
pending.entrySet().removeIf(e -> !e.getKey().equals(challenge) &&
(e.getValue().email.equals(cleanEmail) ||
e.getValue().login.equalsIgnoreCase(login)));
pending.computeIfPresent(challenge,(key,d)->d.update(d.attempts,true,d.verified,d.signedBytes));
}
return new Started(challenge,expires);
}
boolean isValidVerificationCode(byte[] expectedHash, String challenge, String code) {
return (allowTestCode && "777777".equals(code))
|| RegistrationEmailCode.matches(expectedHash, challenge, code);
}
public synchronized Completed confirm(String challenge, String code) throws Exception {
if (publisher == null) throw new IllegalStateException("Free registration disabled");
if (challenge == null || challenge.isBlank())
throw new IllegalArgumentException("Registration challenge missing");
Draft d=pending.get(challenge);
if (d==null || d.expiresAtMs < System.currentTimeMillis()) {
pending.remove(challenge); throw new IllegalArgumentException("Registration challenge missing or expired");
}
if (!d.delivered) throw new IllegalStateException("Verification email is not delivered yet");
if (!d.verified) {
if (!isValidVerificationCode(d.codeHash, challenge, code)) {
if (d.attempts+1 >= MAX_ATTEMPTS) pending.remove(challenge);
else pending.put(challenge,d.update(d.attempts+1,true,false,d.signedBytes));
throw new IllegalArgumentException("Invalid email code");
}
// Если Turbo не ответит, подтверждённая заявка может быть повторена до TTL.
d=d.update(d.attempts,true,true,d.signedBytes);
pending.put(challenge,d);
}
byte[] signed=d.signedBytes;
if(signed==null) {
signed=issuer.issue(d.login,d.root,d.blockchain,d.client,d.email);
d=d.update(d.attempts,true,true,signed);
pending.put(challenge,d);
}
VerifiedFreeRegistrationImporter.ImportResult result=publisher.publishSigned(signed);
// Повтор использует тот же подписанный DataItem, без смены ключей и адреса email.
return new Completed(result.login(),result.dataItemId(),"TURBO_ACCEPTED",result.alreadyImported());
}
public State getStatus(String login) throws Exception {
FreeRegistrationCertificateV1.validateLogin(login);
try (Connection c=DbController.getInstance().getConnection();
PreparedStatement p=c.prepareStatement("""
SELECT i.registration_status,i.free_data_item_id,f.publication_status,f.inner_signature,
i.root_key,i.blockchain_key,i.client_key,n.default_server_login
FROM user_identity_current i
LEFT JOIN free_registration_certificate f ON f.data_item_id=i.free_data_item_id
LEFT JOIN shine_namespace_current n ON n.namespace=i.namespace
WHERE i.normalized_login=?
""")) {
p.setString(1,login.toLowerCase(java.util.Locale.ROOT));
try (ResultSet r=p.executeQuery()) {
return r.next()?new State(r.getString(1),r.getString(2),r.getString(3),
r.getBytes(4)==null?null:Base64.getEncoder().encodeToString(r.getBytes(4)),
r.getString(5),r.getString(6),r.getString(7),r.getString(8))
:new State("NOT_FOUND",null,null,null,null,null,null,null);
}
}
}
}
@@ -1,43 +0,0 @@
package server.archive.registration;
import utils.crypto.Ed25519Util;
import utils.config.AppConfig;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.Base64;
/** Временный signer. Файл вне Git: одно значение Base64 от 32-байтного Ed25519 seed. */
public final class LocalRegistrarSigner implements RegistrarSigner {
private final byte[] seed32;
private final byte[] publicKey32;
private boolean closed;
public LocalRegistrarSigner(byte[] seed) {
if (seed == null || seed.length != 32) throw new IllegalArgumentException("Registrar seed must be 32 bytes");
this.seed32 = seed.clone();
this.publicKey32 = Ed25519Util.derivePublicKey(seed32);
}
public static LocalRegistrarSigner fromConfig(AppConfig config) throws Exception {
if (!config.getBoolean("freeRegistration.enabled", false))
throw new IllegalStateException("Free registration is disabled");
String path = config.getStringOrEmpty("freeRegistration.registrarSeedFile");
if (path.isEmpty()) throw new IllegalStateException("Registrar key path is not configured");
byte[] seed = Base64.getDecoder().decode(Files.readString(Path.of(path), StandardCharsets.UTF_8).trim());
try { return new LocalRegistrarSigner(seed); }
finally { Arrays.fill(seed, (byte) 0); }
}
@Override public synchronized byte[] publicKey32() { return publicKey32.clone(); }
@Override public synchronized byte[] sign(byte[] message) {
if (closed) throw new IllegalStateException("Signer closed");
return Ed25519Util.sign(message, seed32);
}
@Override public synchronized void close() {
Arrays.fill(seed32, (byte) 0);
closed = true;
}
}
@@ -1,8 +0,0 @@
package server.archive.registration;
/** Интерфейс приватного регистратора: private key не передаётся в бизнес-логику. */
public interface RegistrarSigner extends AutoCloseable {
byte[] publicKey32();
byte[] sign(byte[] message);
@Override default void close() {}
}
@@ -1,31 +0,0 @@
package server.archive.registration;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.HexFormat;
/** Одноразовый код не сохраняется в открытом виде и не попадает в журнал. */
final class RegistrationEmailCode {
private static final SecureRandom RANDOM = new SecureRandom();
private RegistrationEmailCode() {}
static String generate() {
return String.format(java.util.Locale.ROOT, "%06d", RANDOM.nextInt(1_000_000));
}
static byte[] hash(String challengeId, String code) {
try {
MessageDigest md = MessageDigest.getInstance("SHA-256");
return md.digest((challengeId + ":" + code).getBytes(StandardCharsets.UTF_8));
} catch (NoSuchAlgorithmException e) {
throw new IllegalStateException("SHA-256 unavailable", e);
}
}
static boolean matches(byte[] expectedHash, String challengeId, String submitted) {
return submitted != null && submitted.matches("[0-9]{6}") &&
MessageDigest.isEqual(expectedHash, hash(challengeId, submitted));
}
}
@@ -1,7 +0,0 @@
package server.archive.registration;
/** Отправка кода. Детали внешнего почтового провайдера не влияют на протокол регистрации. */
@FunctionalInterface
public interface RegistrationEmailSender {
void sendVerificationCode(String recipient, String code) throws Exception;
}
@@ -1,63 +0,0 @@
package server.archive.registration;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.Map;
/** Транзакционная отправка через Resend: HTTP API, без SMTP и внешней Java SDK. */
public final class ResendRegistrationEmailSender implements RegistrationEmailSender {
private static final URI ENDPOINT = URI.create("https://api.resend.com/emails");
private static final String SUBJECT = "SHiNE — код подтверждения email";
private final HttpClient client = HttpClient.newBuilder()
.connectTimeout(Duration.ofSeconds(5)).build();
private final ObjectMapper mapper = new ObjectMapper();
private final String apiKey;
private final String from;
public ResendRegistrationEmailSender(String apiKey, String from) {
if (apiKey == null || apiKey.isBlank())
throw new IllegalStateException("Resend API key is required for free registration");
if (from == null || from.isBlank())
throw new IllegalStateException("Sender email is missing");
this.apiKey = apiKey.trim();
this.from = from.trim();
}
@Override
public void sendVerificationCode(String recipient, String code) throws Exception {
if (recipient == null || recipient.isBlank() || !code.matches("[0-9]{6}"))
throw new IllegalArgumentException("Invalid email verification request");
String text = "Добро пожаловать в SHiNE!\n\n"
+ "Для завершения регистрации введите код подтверждения:\n\n"
+ code + "\n\n"
+ "Код действителен в течение 1 часа.\n\n"
+ "Если вы не регистрировались в SHiNE, просто проигнорируйте это письмо.\n\n"
+ "Команда SHiNE";
String html = "<div style=\"font-family:Arial,sans-serif;max-width:520px;margin:auto;"
+ "padding:24px;color:#1d2433;line-height:1.6\">"
+ "<h2 style=\"margin:0 0 20px\">Добро пожаловать в SHiNE!</h2>"
+ "<p>Для завершения регистрации введите код подтверждения:</p>"
+ "<p style=\"font-size:32px;font-weight:700;letter-spacing:6px\">" + code + "</p>"
+ "<p>Код действителен в течение 1 часа.</p>"
+ "<p style=\"color:#5d6470\">Если вы не регистрировались в SHiNE, "
+ "просто проигнорируйте это письмо.</p><p>Команда SHiNE</p></div>";
String json = mapper.writeValueAsString(Map.of(
"from", from, "to", new String[]{recipient}, "subject", SUBJECT,
"text", text, "html", html));
HttpRequest request = HttpRequest.newBuilder(ENDPOINT)
.header("Authorization", "Bearer " + apiKey)
.header("Content-Type", "application/json")
.timeout(Duration.ofSeconds(12))
.POST(HttpRequest.BodyPublishers.ofString(json))
.build();
// Тело ошибки не выводим: нельзя логировать email или токен провайдера.
HttpResponse<Void> response = client.send(request, HttpResponse.BodyHandlers.discarding());
if (response.statusCode() < 200 || response.statusCode() >= 300)
throw new IllegalStateException("Resend delivery rejected (HTTP " + response.statusCode() + ")");
}
}
@@ -1,184 +0,0 @@
package server.archive.registration;
import shine.db.DbController;
import sync.util.Base58Util;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.Base64;
/** Только верифицированный сертификат. Локальная БД — проекция Arweave/Solana. */
public final class VerifiedFreeRegistrationImporter {
public enum Provenance { TURBO_ACCEPTED, ARWEAVE_CONFIRMED }
public record ImportResult(String login, String dataItemId, boolean alreadyImported, Provenance provenance) {}
private final boolean allowEmailReuse;
public VerifiedFreeRegistrationImporter() {
this(false);
}
public VerifiedFreeRegistrationImporter(boolean allowEmailReuse) {
this.allowEmailReuse = allowEmailReuse;
}
/** Предварительная проверка ДО Turbo: не расходовать кредиты на чужую/битую запись. */
public FreeRegistrationCertificateV1.Verified validateForUpload(byte[] raw) throws Exception {
if (raw == null || raw.length < 200 || raw.length > 16_384)
throw new IllegalArgumentException("Invalid registration size");
blockchain.Ans104DataItem item = new blockchain.Ans104DataItem(raw);
String login = extractCanonicalLogin(item);
try (Connection c = DbController.getInstance().getConnection()) {
String namespace = login.substring(login.indexOf('@') + 1);
var cert = FreeRegistrationCertificateV1.verify(raw, readRegistrar(c, namespace, login));
try (PreparedStatement ps = c.prepareStatement(
"SELECT free_data_item_id FROM user_identity_current WHERE normalized_login=?")) {
ps.setString(1, login.toLowerCase(java.util.Locale.ROOT));
try (ResultSet rs = ps.executeQuery()) {
if (rs.next() && !cert.idBase64Url().equals(rs.getString(1)))
throw new IllegalArgumentException("Login is already registered");
}
}
if (!allowEmailReuse) {
try (PreparedStatement ps = c.prepareStatement(
"SELECT data_item_id FROM free_registration_certificate WHERE email_sha256=?")) {
ps.setBytes(1, cert.emailSha256());
try (ResultSet rs = ps.executeQuery()) {
if (rs.next() && !cert.idBase64Url().equals(rs.getString(1)))
throw new IllegalArgumentException("Email hash belongs to another account");
}
}
}
return cert;
}
}
/** Единая точка импорта: один и тот же raw ANS-104 из Turbo и Arweave. */
public ImportResult importSigned(byte[] raw, Provenance provenance) throws Exception {
if (raw == null || raw.length > 16_384 || raw.length < 200)
throw new IllegalArgumentException("Invalid registration data item size");
// Сначала разбираем/проверяем структурный контейнер, затем сверяем owner с on-chain namespace.
blockchain.Ans104DataItem item = new blockchain.Ans104DataItem(raw);
String login = extractCanonicalLogin(item);
String namespace = login.substring(login.indexOf('@') + 1);
try (Connection c = DbController.getInstance().getConnection()) {
boolean oldAutoCommit = c.getAutoCommit();
c.setAutoCommit(false);
try {
byte[] registrar = readRegistrar(c, namespace, login);
FreeRegistrationCertificateV1.Verified cert = FreeRegistrationCertificateV1.verify(raw, registrar);
String id = cert.idBase64Url();
String publication = provenance == Provenance.ARWEAVE_CONFIRMED ? "ARWEAVE_CONFIRMED" : "TURBO_ACCEPTED";
long now = System.currentTimeMillis();
// Защита от коллизий и двойного импорта: имя и email захвачены индексами UNIQUE.
try (PreparedStatement check = c.prepareStatement("""
SELECT f.raw_signed_data_item, f.publication_status, u.root_key, u.client_key,
u.blockchain_key FROM free_registration_certificate f
JOIN user_identity_current u ON u.login=f.login
WHERE f.data_item_id=? FOR UPDATE OF f
""")) {
check.setString(1, id);
try (ResultSet r = check.executeQuery()) {
if (r.next()) {
if (!Arrays.equals(raw, r.getBytes(1)))
throw new SQLException("DataItem id collision with different raw bytes");
if (!r.getString(3).equals(Base58Util.encode(cert.rootKey())) ||
!r.getString(4).equals(Base58Util.encode(cert.clientKey())) ||
!r.getString(5).equals(Base58Util.encode(cert.blockchainKey())))
throw new SQLException("Accepted identity keys conflict with certificate");
if (provenance == Provenance.ARWEAVE_CONFIRMED) {
try (PreparedStatement up = c.prepareStatement("""
UPDATE free_registration_certificate SET publication_status='ARWEAVE_CONFIRMED',last_seen_at_ms=?
WHERE data_item_id=?
""")) {
up.setLong(1, now); up.setString(2, id); up.executeUpdate();
}
}
c.commit();
return new ImportResult(login, id, true, provenance);
}
}
}
try (PreparedStatement insert = c.prepareStatement("""
INSERT INTO user_identity_current (
login, normalized_login, namespace, registration_source, registration_status,
solana_pda_address, free_data_item_id, root_key, client_key, blockchain_key,
blockchain_name, is_server, registered_at_ms, updated_at_ms)
VALUES (?, ?, ?, 'ARWEAVE', 'FREE_CERT', NULL, ?, ?, ?, ?, ?, false, ?, ?)
""")) {
insert.setString(1, login); insert.setString(2, login.toLowerCase(java.util.Locale.ROOT)); insert.setString(3, namespace);
insert.setString(4, id); insert.setString(5, Base58Util.encode(cert.rootKey()));
insert.setString(6, Base58Util.encode(cert.clientKey()));
insert.setString(7, Base58Util.encode(cert.blockchainKey()));
insert.setString(8, login.toLowerCase(java.util.Locale.ROOT) + "-001"); insert.setLong(9, now); insert.setLong(10, now);
insert.executeUpdate();
}
// blockchain_state — обязательная runtime-проекция новой цепочки.
// Без неё первый пользовательский AddBlock (например, «О себе») будет
// отклонён ещё до проверки подписи.
try (PreparedStatement insert = c.prepareStatement("""
INSERT INTO blockchain_state_store (
login, fork_number, blockchain_key, size_limit, file_size_bytes,
last_block_number, last_block_hash, updated_at_ms)
VALUES (?, 1, ?, 100000, 0, -1, ?, ?)
""")) {
insert.setString(1, login);
// blockchain_state — runtime-слой: его ключ всегда Base64(32),
// как и у пользователей, импортированных из Solana PDA.
insert.setString(2, Base64.getEncoder().encodeToString(cert.blockchainKey()));
insert.setBytes(3, new byte[32]);
insert.setLong(4, now);
insert.executeUpdate();
}
try (PreparedStatement insert = c.prepareStatement("""
INSERT INTO free_registration_certificate (
data_item_id, login, namespace, email_sha256, inner_signature,
raw_signed_data_item, publication_status, registered_at_ms, last_seen_at_ms)
VALUES (?,?,?,?,?,?,?,?,?)
""")) {
insert.setString(1, id); insert.setString(2, login); insert.setString(3, namespace);
insert.setBytes(4, cert.emailSha256()); insert.setBytes(5, cert.innerSignature());
insert.setBytes(6, raw); insert.setString(7, publication);
insert.setLong(8, now); insert.setLong(9, now); insert.executeUpdate();
}
c.commit();
return new ImportResult(login, id, false, provenance);
} catch (Exception e) {
c.rollback(); throw e;
} finally { c.setAutoCommit(oldAutoCommit); }
}
}
private static String extractCanonicalLogin(blockchain.Ans104DataItem item) {
boolean marker = item.tags().contains(new blockchain.Ans104DataItem.Tag("t", "reg"));
if (!marker) throw new IllegalArgumentException("Not a registration DataItem");
byte[] bytes = item.data();
if (bytes.length < 3 || bytes[0] != 1 || bytes[1] != 0) throw new IllegalArgumentException("Bad certificate header");
int len = bytes[2] & 0xff;
if (len < 3 || len > 30 || bytes.length < 3 + len + 96 + 64 + 32)
throw new IllegalArgumentException("Invalid certificate login length");
return FreeRegistrationCertificateV1.validateLogin(
new String(bytes, 3, len, java.nio.charset.StandardCharsets.UTF_8));
}
private static byte[] readRegistrar(Connection c, String namespace, String login) throws Exception {
try (PreparedStatement ps = c.prepareStatement("""
SELECT registrar_pubkey, min_localpart_len, default_server_login
FROM shine_namespace_current WHERE namespace=? AND namespace_type=2
""")) {
ps.setString(1, namespace);
try (ResultSet rs = ps.executeQuery()) {
if (!rs.next()) throw new IllegalStateException("Unknown/free namespace not yet synchronized");
if (login.indexOf('@') < rs.getInt("min_localpart_len"))
throw new IllegalArgumentException("Login shorter than namespace minimum");
if (rs.getString("default_server_login") == null || rs.getString("default_server_login").isBlank())
throw new IllegalArgumentException("Namespace has no access server");
byte[] key = Base58Util.decode(rs.getString("registrar_pubkey"));
if (key.length != 32) throw new IllegalArgumentException("Invalid registrar pubkey");
return key;
}
}
}
}
@@ -1 +0,0 @@
0200a9de19b3551ace117973b80d632503bf2a55f0aa2490deb1474a280b675fa01bb2ccb5890faadcb213d3882fb21a7af13702526a569f7807b1c8b6963c0be402174553b456dddfc6908ecab1c101fe6ab21e2baa0617795b7d43a63482993fd500000300000000000000390000000000000006064170701074657374353539310274067265671050726f746f636f6c345348694e452d467265652d526567697374726174696f6e2d563100010008626f62406672656503a107bff3ce10be1d70dd18e74bc09967e4d6309ba50d5f1ddc8664125531b829acbae141bccaf0b22e1a94d34d0bc7361e526d0bfe12c89794bc9322966dd72543b92ff1095511476adc8369db6ddc933665a11978dda1404ee1066ca9559de2edfcd8b1b7a1823f56b827ddfa8a3682793e036141b526467ae346e220d08757d0a878a2f722562e6d3132ef9df04b1ab9e2f65d72bb0f48c17b7ada3e5a0acbc605c49fd774ff4d9ea789d8f6bffa719e9774cb86f62d11fd244121150956
@@ -1,36 +0,0 @@
package server.archive;
import blockchain.Ans104DataItem;
import org.junit.jupiter.api.Test;
import utils.crypto.Ed25519Util;
import java.nio.charset.StandardCharsets;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
final class Ans104BundleTest {
@Test
void writeReadAndFindPreserveExactDataItems() {
byte[] a = item("a");
byte[] b = item("b");
byte[] bundle = Ans104Bundle.write(List.of(a, b));
List<Ans104Bundle.Entry> entries = Ans104Bundle.read(bundle, 10);
assertEquals(2, entries.size());
assertArrayEquals(a, entries.get(0).rawDataItem());
assertArrayEquals(b, entries.get(1).rawDataItem());
byte[] bId = new Ans104DataItem(b).id32();
assertArrayEquals(b, Ans104Bundle.find(bundle, bId, 10));
}
private static byte[] item(String payload) {
byte[] privateKey = Ed25519Util.generatePrivateKeyFromString("bundle-" + payload);
byte[] owner = Ed25519Util.derivePublicKey(privateKey);
byte[] data = payload.getBytes(StandardCharsets.UTF_8);
List<Ans104DataItem.Tag> tags = List.of(new Ans104DataItem.Tag(blockchain.ShineProtocolTags.APP_TAG_NAME, blockchain.ShineProtocolTags.APP_TAG_VALUE));
byte[] signature = Ed25519Util.sign(Ans104DataItem.buildSigningMessage(owner, tags, data), privateKey);
return Ans104DataItem.serializeEd25519(signature, owner, tags, data);
}
}
@@ -1,43 +0,0 @@
package server.archive;
import server.archive.registration.*;
import blockchain.Ans104DataItem;
import blockchain.ShineProtocolTags;
import utils.crypto.Ed25519Util;
import java.util.Arrays;
import java.util.HexFormat;
/** Standalone test (no legacy signed fixture): certificate issue/verify for CURRENT App tag. */
public final class FreeRegistrationCertificateV1Check {
static final HexFormat HEX = HexFormat.of();
public static void main(String[] args) throws Exception {
byte[] seed = Ed25519Util.generatePrivateKeyFromString("TEST-only-reg-v1-check");
byte[] root = HEX.parseHex("03a107bff3ce10be1d70dd18e74bc09967e4d6309ba50d5f1ddc8664125531b8");
byte[] chain = HEX.parseHex("29acbae141bccaf0b22e1a94d34d0bc7361e526d0bfe12c89794bc9322966dd7");
byte[] client = HEX.parseHex("2543b92ff1095511476adc8369db6ddc933665a11978dda1404ee1066ca9559d");
try (var signer = new LocalRegistrarSigner(seed)) {
byte[] cert = FreeRegistrationCertificateV1.issue("SuperMan@free", root, chain, client,
" Alice.Example+Tag@Example.COM ", signer);
var item = new Ans104DataItem(cert);
if (!item.hasTag(ShineProtocolTags.APP_TAG_NAME, ShineProtocolTags.APP_TAG_VALUE))
throw new AssertionError("Current App tag missing");
var result = FreeRegistrationCertificateV1.verify(cert, signer.publicKey32());
if (!"SuperMan@free".equals(result.login()) || !Arrays.equals(result.rootKey(), root)
|| !Arrays.equals(result.blockchainKey(), chain) || !Arrays.equals(result.clientKey(), client))
throw new AssertionError("Certificate identity corrupted");
if (!Arrays.equals(result.emailSha256(), HEX.parseHex(
"cbc605c49fd774ff4d9ea789d8f6bffa719e9774cb86f62d11fd244121150956")))
throw new AssertionError("Email normalization differs");
byte[] bad = cert.clone(); bad[bad.length - 1] ^= 1;
try { FreeRegistrationCertificateV1.verify(bad, signer.publicKey32());
throw new AssertionError("Email bit flip accepted"); }
catch (IllegalArgumentException expected) {}
bad = cert.clone(); bad[bad.length - 40] ^= 1;
try { FreeRegistrationCertificateV1.verify(bad, signer.publicKey32());
throw new AssertionError("Inner signature tampering accepted"); }
catch (IllegalArgumentException expected) {}
}
System.out.println("PASS: current App=" + ShineProtocolTags.APP_TAG_VALUE
+ ", Java registrar inner+outer Ed25519, original case, email, tamper rejection");
}
}
@@ -1,41 +0,0 @@
package server.archive;
import server.archive.registration.*;
import javax.sql.DataSource;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HexFormat;
/** Только проверки без БД/сети; полное E2E требует PostgreSQL и Turbo. */
public final class FreeRegistrationWorkflowLocalCheck {
public static void main(String[] args) throws Exception {
var signer = new RegistrarSigner() {
public byte[] publicKey32() { return new byte[32]; }
public byte[] sign(byte[] message) { return new byte[64]; }
};
DataSource noDb = new DataSource() {
public java.sql.Connection getConnection() throws java.sql.SQLException { throw new java.sql.SQLException("No database in local test"); }
public java.sql.Connection getConnection(String u, String p) throws java.sql.SQLException { return getConnection(); }
public java.io.PrintWriter getLogWriter() {return null;}
public void setLogWriter(java.io.PrintWriter x) {}
public void setLoginTimeout(int x) {}
public int getLoginTimeout() {return 0;}
public java.util.logging.Logger getParentLogger() {return java.util.logging.Logger.getAnonymousLogger();}
public <T> T unwrap(Class<T> iface) throws java.sql.SQLException {throw new java.sql.SQLException("unsupported");}
public boolean isWrapperFor(Class<?> iface) {return false;}
};
var issuer = new FreeRegistrationIssuer(noDb, signer);
var importer = new VerifiedFreeRegistrationImporter();
var workflow = new FreeRegistrationWorkflow(issuer,
new FreeRegistrationPublisher(issuer, new TurboDataItemUploader(ArweaveBlocksConfig.load()), importer),
(email, code) -> { throw new AssertionError("No real email in an offline check"); },
false, false, AllowedEmailDomains.load(Files.isRegularFile(Path.of("allowed-email-domains.txt"))
? Path.of("allowed-email-domains.txt") : Path.of("../allowed-email-domains.txt")));
try { workflow.confirm("unknown", "123456"); throw new AssertionError("Missing challenge accepted"); }
catch (IllegalArgumentException expected) { }
try { importer.importSigned(new byte[]{1,2,3}, VerifiedFreeRegistrationImporter.Provenance.TURBO_ACCEPTED);
throw new AssertionError("Invalid bytes accepted"); }
catch (IllegalArgumentException expected) { }
System.out.println("PASS: workflow missing challenge + reject invalid signed bytes");
}
}
@@ -1,47 +0,0 @@
package server.archive.registration;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
/** Самостоятельный офлайн-тест: javac AllowedEmailDomains.java AllowedEmailDomainsCheck.java + java. */
public final class AllowedEmailDomainsCheck {
public static void main(String[] args) throws Exception {
Path dir = Files.createTempDirectory("shine-email-domains-test-");
try {
Path file = dir.resolve("allowed-email-domains.txt");
Files.writeString(file, "# Test\n Gmail.com \nproton.me\n\n", StandardCharsets.UTF_8);
AllowedEmailDomains allowed = AllowedEmailDomains.load(file);
expect(allowed.permits("User@GMAIL.COM"), "case insensitive match");
expect(allowed.permits(" user@proton.me "), "trimmed match");
expect(!allowed.permits("user@gmail.com.evil.org"), "suffix bypass");
expect(!allowed.permits("user@sub.gmail.com"), "subdomain bypass");
expect(!allowed.permits("user@other.com"), "unknown domain");
expect(!allowed.permits("user@@gmail.com"), "invalid multiple @");
expect(!allowed.permits("@gmail.com"), "missing local part");
expect(!allowed.permits(null), "null address");
Files.writeString(file, "# no domains\n \n", StandardCharsets.UTF_8);
expectLoadFailure(file, "empty file");
Files.writeString(file, "*.gmail.com\n", StandardCharsets.UTF_8);
expectLoadFailure(file, "wildcard not allowed");
Files.writeString(file, "gmail.com\ninvalid_domain\n", StandardCharsets.UTF_8);
expectLoadFailure(file, "invalid line not ignored");
Files.delete(file);
expectLoadFailure(file, "missing file");
System.out.println("PASS: allowed email domains, strict matching, fail-closed");
} finally {
try (var files = Files.list(dir)) { files.forEach(path -> {try {Files.deleteIfExists(path);}catch(Exception ex){throw new RuntimeException(ex);}}); }
Files.deleteIfExists(dir);
}
}
private static void expect(boolean condition, String scenario) {
if (!condition) throw new AssertionError(scenario);
}
private static void expectLoadFailure(Path file, String scenario) throws Exception {
try {
AllowedEmailDomains.load(file);
throw new AssertionError("Invalid allowlist accepted: " + scenario);
} catch (java.io.IOException expected) { }
}
}
@@ -1,17 +0,0 @@
package server.archive.registration;
/** Локальная проверка генератора и сверки кода без БД/HTTP. */
public final class RegistrationEmailCodeCheck {
public static void main(String[] args) {
for (int i=0; i<1000; ++i) {
String code = RegistrationEmailCode.generate();
if (!code.matches("[0-9]{6}")) throw new AssertionError("Wrong length");
byte[] hash = RegistrationEmailCode.hash("challenge-id", code);
if (!RegistrationEmailCode.matches(hash, "challenge-id", code)) throw new AssertionError("Cannot verify");
if (RegistrationEmailCode.matches(hash, "another-challenge", code)) throw new AssertionError("Challenge replay");
if (RegistrationEmailCode.matches(hash, "challenge-id", "1111")) throw new AssertionError("Old demo code accepted");
if (RegistrationEmailCode.matches(hash, "challenge-id", "bad")) throw new AssertionError("Bad code accepted");
}
System.out.println("PASS: email code generation and challenge binding");
}
}
@@ -1,21 +0,0 @@
package server.archive.registration;
/** Offline проверка часового TTL на уровне UX отдельно; bypass должен быть строго opt-in. */
public final class RegistrationEmailSettingsCheck {
public static void main(String[] args) {
byte[] digest = RegistrationEmailCode.hash("challenge", "123456");
var safe = new FreeRegistrationWorkflow(null, null, null, false);
var test = new FreeRegistrationWorkflow(null, null, null, true);
if (safe.isValidVerificationCode(digest, "challenge", "777777"))
throw new AssertionError("Cheat unexpectedly enabled by default");
if (!test.isValidVerificationCode(digest, "challenge", "777777"))
throw new AssertionError("Explicit test code not accepted");
if (!safe.isValidVerificationCode(digest, "challenge", "123456"))
throw new AssertionError("Real code rejected");
if (test.isValidVerificationCode(digest, "challenge", "1111"))
throw new AssertionError("Old demo code unexpectedly accepted");
if (test.isValidVerificationCode(digest, "challenge", "777778"))
throw new AssertionError("Invalid code unexpectedly accepted");
System.out.println("PASS: real code and opt-in test code");
}
}
@@ -1,363 +0,0 @@
package blockchain;
import utils.crypto.Ed25519Util;
import java.io.ByteArrayOutputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
/**
* Minimal ANS-104 DataItem parser/verifier used by SHiNE.
*
* SHiNE accepts only generic Ed25519 signature type 2:
* uint16le signatureType
* signature[64]
* owner[32]
* target_present[1] + target[32] when present
* anchor_present[1] + anchor[32] when present
* tags_count uint64le
* tags_size uint64le
* avro_tags[tags_size]
* data[*]
*
* The signing message matches the deployed arbundles/Turbo DataItem implementation:
* deepHash(["dataitem", "1", signatureType, owner, target, anchor, rawAvroTags, data]).
*/
public final class Ans104DataItem {
public static final int SIGNATURE_TYPE_ED25519 = 2;
public static final int SIGNATURE_LEN = 64;
public static final int OWNER_LEN = 32;
public static final int OPTIONAL_FIELD_LEN = 32;
public static final int ID_LEN = 32;
public static final int MAX_DATA_ITEM_BYTES = 8 * 1024 * 1024;
public static final int MAX_TAGS_BYTES = 64 * 1024;
public static final long MAX_TAGS_COUNT = 128;
public record Tag(String name, String value) {}
private final int signatureType;
private final byte[] signature;
private final byte[] owner;
private final byte[] target;
private final byte[] anchor;
private final long tagsCount;
private final byte[] rawTags;
private final List<Tag> tags;
private final byte[] data;
private final byte[] rawBytes;
private final byte[] id;
public Ans104DataItem(byte[] bytes) {
Objects.requireNonNull(bytes, "bytes == null");
if (bytes.length < 2 + SIGNATURE_LEN + OWNER_LEN + 1 + 1 + 8 + 8 + 1) {
throw new IllegalArgumentException("ANS-104 DataItem too short: " + bytes.length);
}
if (bytes.length > MAX_DATA_ITEM_BYTES) {
throw new IllegalArgumentException("ANS-104 DataItem too large: " + bytes.length);
}
ByteBuffer bb = ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN);
this.signatureType = Short.toUnsignedInt(bb.getShort());
if (signatureType != SIGNATURE_TYPE_ED25519) {
throw new IllegalArgumentException("Unsupported ANS-104 signature type: " + signatureType + " (expected 2)");
}
this.signature = readExact(bb, SIGNATURE_LEN, "signature");
this.owner = readExact(bb, OWNER_LEN, "owner");
this.target = readOptional32(bb, "target");
this.anchor = readOptional32(bb, "anchor");
this.tagsCount = readUnsignedLongAsNonNegative(bb, "tags_count");
long tagsSizeLong = readUnsignedLongAsNonNegative(bb, "tags_size");
if (tagsCount > MAX_TAGS_COUNT) {
throw new IllegalArgumentException("Too many ANS-104 tags: " + tagsCount);
}
if (tagsSizeLong > MAX_TAGS_BYTES || tagsSizeLong > bb.remaining()) {
throw new IllegalArgumentException("Bad ANS-104 tags_size: " + tagsSizeLong + ", remaining=" + bb.remaining());
}
this.rawTags = readExact(bb, (int) tagsSizeLong, "tags");
this.tags = Collections.unmodifiableList(parseAvroTags(rawTags, tagsCount));
this.data = new byte[bb.remaining()];
bb.get(this.data);
this.rawBytes = Arrays.copyOf(bytes, bytes.length);
this.id = sha256(signature);
}
public int signatureType() { return signatureType; }
public byte[] signature64() { return Arrays.copyOf(signature, signature.length); }
public byte[] owner32() { return Arrays.copyOf(owner, owner.length); }
public byte[] target() { return Arrays.copyOf(target, target.length); }
public byte[] anchor() { return Arrays.copyOf(anchor, anchor.length); }
public long tagsCount() { return tagsCount; }
public byte[] rawTags() { return Arrays.copyOf(rawTags, rawTags.length); }
public List<Tag> tags() { return tags; }
public byte[] data() { return Arrays.copyOf(data, data.length); }
public byte[] rawBytes() { return Arrays.copyOf(rawBytes, rawBytes.length); }
public byte[] id32() { return Arrays.copyOf(id, id.length); }
public String tagValue(String name) {
if (name == null) return null;
for (Tag tag : tags) {
if (name.equals(tag.name())) return tag.value();
}
return null;
}
public boolean hasTag(String name, String value) {
for (Tag tag : tags) {
if (Objects.equals(name, tag.name()) && Objects.equals(value, tag.value())) return true;
}
return false;
}
public boolean verifySignature() {
return Ed25519Util.verify(signingMessage(), signature, owner);
}
public boolean ownerEquals(byte[] expectedOwner32) {
return expectedOwner32 != null && expectedOwner32.length == OWNER_LEN && Arrays.equals(owner, expectedOwner32);
}
public byte[] signingMessage() {
return buildSigningMessage(owner, target, anchor, tags, data);
}
/**
* Builds the exact ANS-104 signing message for generic Ed25519 DataItems.
* Useful for SHiNE clients/tests that must sign a DataItem before serializing it.
*/
public static byte[] buildSigningMessage(byte[] owner32, List<Tag> tags, byte[] data) {
return buildSigningMessage(owner32, new byte[0], new byte[0], tags, data);
}
public static byte[] buildSigningMessage(byte[] owner32, byte[] target, byte[] anchor, List<Tag> tags, byte[] data) {
requireLen(owner32, OWNER_LEN, "owner");
byte[] safeTarget = target == null ? new byte[0] : Arrays.copyOf(target, target.length);
byte[] safeAnchor = anchor == null ? new byte[0] : Arrays.copyOf(anchor, anchor.length);
if (!(safeTarget.length == 0 || safeTarget.length == OPTIONAL_FIELD_LEN)) {
throw new IllegalArgumentException("target must be empty or 32 bytes");
}
if (!(safeAnchor.length == 0 || safeAnchor.length == OPTIONAL_FIELD_LEN)) {
throw new IllegalArgumentException("anchor must be empty or 32 bytes");
}
List<Tag> safeTags = validateTags(tags);
byte[] safeData = data == null ? new byte[0] : Arrays.copyOf(data, data.length);
byte[] rawTags = serializeAvroTags(safeTags);
return deepHash(List.of(
utf8("dataitem"),
utf8("1"),
utf8(Integer.toString(SIGNATURE_TYPE_ED25519)),
Arrays.copyOf(owner32, owner32.length),
safeTarget,
safeAnchor,
rawTags,
safeData
));
}
/** Serialize one SHiNE-ready ANS-104 DataItem with empty target/anchor. */
public static byte[] serializeEd25519(byte[] signature64, byte[] owner32, List<Tag> tags, byte[] data) {
requireLen(signature64, SIGNATURE_LEN, "signature");
requireLen(owner32, OWNER_LEN, "owner");
List<Tag> safeTags = validateTags(tags);
byte[] rawTags = serializeAvroTags(safeTags);
byte[] safeData = data == null ? new byte[0] : data;
ByteArrayOutputStream out = new ByteArrayOutputStream(
2 + SIGNATURE_LEN + OWNER_LEN + 1 + 1 + 8 + 8 + rawTags.length + safeData.length);
writeU16LE(out, SIGNATURE_TYPE_ED25519);
out.writeBytes(signature64);
out.writeBytes(owner32);
out.write(0); // target absent
out.write(0); // anchor absent
writeU64LE(out, safeTags.size());
writeU64LE(out, rawTags.length);
out.writeBytes(rawTags);
out.writeBytes(safeData);
return out.toByteArray();
}
private static byte[] readOptional32(ByteBuffer bb, String name) {
if (!bb.hasRemaining()) throw new IllegalArgumentException("Missing " + name + " presence byte");
int present = Byte.toUnsignedInt(bb.get());
if (present == 0) return new byte[0];
if (present != 1) throw new IllegalArgumentException("Bad " + name + " presence byte: " + present);
return readExact(bb, OPTIONAL_FIELD_LEN, name);
}
private static byte[] readExact(ByteBuffer bb, int len, String field) {
if (len < 0 || bb.remaining() < len) {
throw new IllegalArgumentException("ANS-104 " + field + " truncated: need=" + len + " remaining=" + bb.remaining());
}
byte[] out = new byte[len];
bb.get(out);
return out;
}
private static long readUnsignedLongAsNonNegative(ByteBuffer bb, String field) {
if (bb.remaining() < 8) throw new IllegalArgumentException("Missing ANS-104 " + field);
long v = bb.getLong();
if (v < 0) throw new IllegalArgumentException("ANS-104 " + field + " exceeds signed long range");
return v;
}
private static List<Tag> validateTags(List<Tag> tags) {
List<Tag> safe = tags == null ? List.of() : List.copyOf(tags);
if (safe.size() > MAX_TAGS_COUNT) {
throw new IllegalArgumentException("Too many ANS-104 tags: " + safe.size());
}
for (Tag tag : safe) {
if (tag == null || tag.name() == null || tag.value() == null || tag.name().isEmpty() || tag.value().isEmpty()) {
throw new IllegalArgumentException("ANS-104 tag name/value must be non-empty");
}
if (utf8(tag.name()).length > 1024) throw new IllegalArgumentException("ANS-104 tag name exceeds 1024 bytes");
if (utf8(tag.value()).length > 3072) throw new IllegalArgumentException("ANS-104 tag value exceeds 3072 bytes");
}
return safe;
}
private static byte[] serializeAvroTags(List<Tag> tags) {
ByteArrayOutputStream out = new ByteArrayOutputStream();
if (!tags.isEmpty()) {
writeAvroLong(out, tags.size());
for (Tag tag : tags) {
writeAvroString(out, tag.name());
writeAvroString(out, tag.value());
}
}
writeAvroLong(out, 0); // array terminator; also the complete encoding for an empty array
byte[] raw = out.toByteArray();
if (raw.length > MAX_TAGS_BYTES) throw new IllegalArgumentException("ANS-104 tags exceed " + MAX_TAGS_BYTES + " bytes");
return raw;
}
private static void writeAvroString(ByteArrayOutputStream out, String value) {
byte[] bytes = utf8(value);
writeAvroLong(out, bytes.length);
out.writeBytes(bytes);
}
private static void writeAvroLong(ByteArrayOutputStream out, long value) {
long n = (value << 1) ^ (value >> 63);
while ((n & ~0x7fL) != 0) {
out.write((int) ((n & 0x7f) | 0x80));
n >>>= 7;
}
out.write((int) n);
}
private static void writeU16LE(ByteArrayOutputStream out, int value) {
out.write(value & 0xff);
out.write((value >>> 8) & 0xff);
}
private static void writeU64LE(ByteArrayOutputStream out, long value) {
for (int i = 0; i < 8; i++) out.write((int) ((value >>> (8 * i)) & 0xff));
}
private static void requireLen(byte[] bytes, int expected, String name) {
if (bytes == null || bytes.length != expected) {
throw new IllegalArgumentException(name + " must be " + expected + " bytes");
}
}
private static List<Tag> parseAvroTags(byte[] raw, long declaredCount) {
AvroCursor c = new AvroCursor(raw);
List<Tag> out = new ArrayList<>();
while (!c.eof()) {
long count = c.readLong();
if (count == 0) break;
if (count < 0) {
count = -count;
long blockBytes = c.readLong();
if (blockBytes < 0) throw new IllegalArgumentException("Negative Avro tag block size");
}
if (count > MAX_TAGS_COUNT || out.size() + count > MAX_TAGS_COUNT) {
throw new IllegalArgumentException("Too many Avro tags");
}
for (long i = 0; i < count; i++) {
String name = c.readString();
String value = c.readString();
if (name.isEmpty() || value.isEmpty()) throw new IllegalArgumentException("ANS-104 tag name/value must be non-empty");
if (name.getBytes(StandardCharsets.UTF_8).length > 1024) throw new IllegalArgumentException("ANS-104 tag name exceeds 1024 bytes");
if (value.getBytes(StandardCharsets.UTF_8).length > 3072) throw new IllegalArgumentException("ANS-104 tag value exceeds 3072 bytes");
out.add(new Tag(name, value));
}
}
if (!c.eof()) {
throw new IllegalArgumentException("Trailing bytes in ANS-104 Avro tags");
}
if (out.size() != declaredCount) {
throw new IllegalArgumentException("ANS-104 tags_count mismatch: declared=" + declaredCount + " parsed=" + out.size());
}
return out;
}
private static final class AvroCursor {
private final byte[] data;
private int p;
private AvroCursor(byte[] data) { this.data = data == null ? new byte[0] : data; }
boolean eof() { return p == data.length; }
long readLong() {
long raw = 0;
int shift = 0;
while (true) {
if (p >= data.length) throw new IllegalArgumentException("Truncated Avro long");
int b = data[p++] & 0xff;
raw |= (long) (b & 0x7f) << shift;
if ((b & 0x80) == 0) break;
shift += 7;
if (shift > 63) throw new IllegalArgumentException("Avro long too large");
}
return (raw >>> 1) ^ -(raw & 1L);
}
String readString() {
long len = readLong();
if (len < 0 || len > Integer.MAX_VALUE || p + len > data.length) {
throw new IllegalArgumentException("Bad Avro string length: " + len);
}
String s = new String(data, p, (int) len, StandardCharsets.UTF_8);
p += (int) len;
return s;
}
}
private static byte[] deepHash(Object item) {
if (item instanceof byte[] bytes) {
return deepHashBlob(bytes);
}
if (item instanceof List<?> items) {
byte[] acc = sha384(utf8("list" + items.size()));
for (Object child : items) {
acc = sha384(concat(acc, deepHash(child)));
}
return acc;
}
throw new IllegalArgumentException("Unsupported deepHash item: " + (item == null ? "null" : item.getClass()));
}
private static byte[] deepHashBlob(byte[] bytes) {
byte[] tag = utf8("blob" + bytes.length);
return sha384(concat(sha384(tag), sha384(bytes)));
}
private static byte[] utf8(String s) { return s.getBytes(StandardCharsets.UTF_8); }
private static byte[] sha256(byte[] b) { return digest("SHA-256", b); }
private static byte[] sha384(byte[] b) { return digest("SHA-384", b); }
private static byte[] digest(String alg, byte[] b) {
try { return MessageDigest.getInstance(alg).digest(b); }
catch (Exception e) { throw new IllegalStateException(alg + " unavailable", e); }
}
private static byte[] concat(byte[] a, byte[] b) {
ByteArrayOutputStream out = new ByteArrayOutputStream(a.length + b.length);
out.writeBytes(a); out.writeBytes(b); return out.toByteArray();
}
}
@@ -9,120 +9,364 @@ import java.util.Arrays;
import java.util.Objects;
/**
* SHiNE user block, Frame v1, carried as the data payload of an ANS-104 DataItem.
* BchBlockEntry — универсальный блок формата SHiNE (Frame v0).
*
* The constructor accepts the complete serialized ANS-104 DataItem because this is
* exactly what is stored in PostgreSQL and exchanged between servers.
* =========================================================================
* FRAME v0 — ФИКСИРОВАННЫЙ ФОРМАТ БЛОКА (ДОКУМЕНТ ПРОТОКОЛА)
* =========================================================================
*
* SHiNE Frame v1 (all integer fields BigEndian):
* [2] frameCode = 0x0001
* [32] prevHash32 = SHA-256(Frame v1 bytes of previous SHiNE block)
* [32] back32Hash32 = SHA-256(Frame v1 bytes of block N-32), or zero for N<32
* [4] blockSize = exact Frame v1 byte length
* [4] blockNumber
* [8] timestamp unix seconds
* [2] type
* [2] subType
* [2] version
* [N] bodyBytes
* Все числа BigEndian.
*
* The user signature is NOT stored in this frame. It is the single Ed25519/Solana
* signature of the surrounding ANS-104 DataItem.
* PREIMAGE (входит в blockSize, подписывается):
* [2] frameCode (uint16) код/версия рамки:
* - 0x0000 = Frame v0 (текущий)
* [32] prevHash32 (bytes) SHA-256(preimage) предыдущего блока (цепочка)
* [4] blockSize (int32) размер preimage (в байтах), ВКЛЮЧАЯ frameCode,
* НО БЕЗ sigMarker и БЕЗ signature64
* [4] blockNumber (int32) глобальный номер блока (>=0)
* [8] timestamp (int64) unix seconds
* [2] type (uint16) тип сообщения
* [2] subType (uint16) подтип сообщения
* [2] version (uint16) версия формата сообщения
* [N] bodyBytes (bytes) тело сообщения (БЕЗ type/subType/version)
*
* TAIL (НЕ входит в blockSize, НЕ подписывается в Frame v0):
* [2] sigMarker (uint16) маркер подписи:
* - 0x0100 (256) = далее подпись Ed25519 64 байта
* [64] signature64 (bytes) Ed25519 signature над hash32
*
* hash32 НЕ хранится в блоке.
* hash32 вычисляется при парсинге:
* preimage = первые blockSize байт
* hash32 = SHA-256(preimage)
*
* Правила MVP-парсера (Frame v0):
* - frameCode должен быть строго 0x0000, иначе REJECT.
* - sigMarker должен быть строго 0x0100, иначе REJECT.
* - подпись обязана присутствовать всегда (sigMarker+signature64).
* - НИКАКИХ fallback-веток “если маркер другой, то подписи нет/другой хвост”.
*
* Важно по безопасности:
* - sigMarker в v0 не входит в подписываемые байты → его можно подменить,
* поэтому единственная безопасная логика: "если не 0x0100 — reject".
* =========================================================================
*/
public final class BchBlockEntry {
public static final int HASH_LEN = 32;
public static final int FRAME_CODE_V1 = 0x0001;
public static final int MAX_BLOCK_FULL_BYTES = Ans104DataItem.MAX_DATA_ITEM_BYTES;
public static final long MAX_FUTURE_SECONDS = 60;
public static final int FRAME_HEADER_SIZE = 2 + 32 + 32 + 4 + 4 + 8 + 2 + 2 + 2;
public final int frameCode;
public final byte[] prevHash32;
public final byte[] back32Hash32;
public final int blockSize;
public final int blockNumber;
public static final int SIGNATURE_LEN = 64;
public static final int HASH_LEN = 32;
public static final int FRAME_CODE_LEN = 2;
public static final int SIG_MARKER_LEN = 2;
/** Frame v0 */
public static final int FRAME_CODE_V0 = 0x0000;
/** sigMarker: 256 = 0x0100 */
public static final int SIG_MARKER_ED25519 = 0x0100;
/**
* Максимальный допустимый размер блока (fullBytes = preimage + sigMarker + signature),
* чтобы не уложить сервер по памяти/диску.
*/
public static final int MAX_BLOCK_FULL_BYTES = 4 * 1024 * 1024;
/**
* Насколько блок может “обгонять” текущее время (защита от кривых часов/вбросов).
* Если timestamp больше now + 60 сек — блок считаем неверным.
*/
public static final long MAX_FUTURE_SECONDS = 60;
/**
* Размер фиксированной части PREIMAGE (без bodyBytes).
*
* PREIMAGE header:
* frameCode(2) + prevHash32(32) + blockSize(4) + blockNumber(4) + timestamp(8)
* + type(2) + subType(2) + version(2)
*/
public static final int PREIMAGE_HEADER_SIZE =
2 // frameCode
+ 32 // prevHash32
+ 4 // blockSize
+ 4 // blockNumber
+ 8 // timestamp
+ 2 // type
+ 2 // subType
+ 2; // version
/** Минимальный полный размер блока (без bodyBytes). */
public static final int MIN_FULL_BYTES =
PREIMAGE_HEADER_SIZE + SIG_MARKER_LEN + SIGNATURE_LEN;
// --- HEADER (PREIMAGE) ---
public final int frameCode; // uint16 (v0=0)
public final byte[] prevHash32; // 32
public final int blockSize; // preimage size (включая frameCode)
public final int blockNumber; // >=0
public final long timestamp;
public final short type;
public final short subType;
public final short version;
// --- BODY (PREIMAGE) ---
public final byte[] bodyBytes;
/** Распарсенное тело (создаётся сразу при парсинге блока). */
public final BodyRecord body;
private final Ans104DataItem dataItem;
private final byte[] frameBytes;
private final byte[] hash32;
// --- TAIL ---
public final int sigMarker; // uint16 (v0: 0x0100)
private final byte[] signature64; // 64
/** Parse a complete serialized ANS-104 DataItem containing one SHiNE Frame v1. */
public BchBlockEntry(byte[] fullDataItemBytes) {
Objects.requireNonNull(fullDataItemBytes, "fullDataItemBytes == null");
this.dataItem = new Ans104DataItem(fullDataItemBytes);
this.frameBytes = dataItem.data();
if (frameBytes.length < FRAME_HEADER_SIZE) {
throw new IllegalArgumentException("SHiNE Frame v1 too short: " + frameBytes.length);
// --- derived ---
private final byte[] hash32; // 32, computed
private final byte[] preimage; // blockSize bytes
private final byte[] fullBytes; // preimage + sigMarker + signature
/* ===================================================================== */
/* ====================== Конструктор из байт ========================== */
/* ===================================================================== */
public BchBlockEntry(byte[] fullBytes) {
Objects.requireNonNull(fullBytes, "fullBytes == null");
if (fullBytes.length < MIN_FULL_BYTES) {
throw new IllegalArgumentException("Block too short: " + fullBytes.length + " < " + MIN_FULL_BYTES);
}
if (fullBytes.length > MAX_BLOCK_FULL_BYTES) {
throw new IllegalArgumentException("Block too large: " + fullBytes.length + " > " + MAX_BLOCK_FULL_BYTES);
}
ByteBuffer bb = ByteBuffer.wrap(frameBytes).order(ByteOrder.BIG_ENDIAN);
ByteBuffer bb = ByteBuffer.wrap(fullBytes).order(ByteOrder.BIG_ENDIAN);
// [2] frameCode
this.frameCode = Short.toUnsignedInt(bb.getShort());
if (frameCode != FRAME_CODE_V1) {
throw new IllegalArgumentException(String.format("Bad SHiNE frameCode: 0x%04X (expected 0x%04X)", frameCode, FRAME_CODE_V1));
if (this.frameCode != FRAME_CODE_V0) {
throw new IllegalArgumentException(String.format(
"Bad frameCode: 0x%04X (expected 0x%04X)", this.frameCode, FRAME_CODE_V0
));
}
// [32] prevHash32
this.prevHash32 = new byte[32];
bb.get(prevHash32);
this.back32Hash32 = new byte[32];
bb.get(back32Hash32);
bb.get(this.prevHash32);
// [4] blockSize
this.blockSize = bb.getInt();
if (blockSize != frameBytes.length || blockSize < FRAME_HEADER_SIZE) {
throw new IllegalArgumentException("SHiNE blockSize mismatch: declared=" + blockSize + " actual=" + frameBytes.length);
if (blockSize < PREIMAGE_HEADER_SIZE) {
throw new IllegalArgumentException("blockSize too small: " + blockSize + " < " + PREIMAGE_HEADER_SIZE);
}
// fullLen must match exactly: blockSize + sigMarker(2) + signature(64)
int expectedFullLen = blockSize + SIG_MARKER_LEN + SIGNATURE_LEN;
if (expectedFullLen != fullBytes.length) {
throw new IllegalArgumentException("blockSize mismatch: blockSize=" + blockSize
+ " expectedFullLen=" + expectedFullLen
+ " fullLen=" + fullBytes.length);
}
if (expectedFullLen > MAX_BLOCK_FULL_BYTES) {
throw new IllegalArgumentException("Block too large by blockSize: " + expectedFullLen + " > " + MAX_BLOCK_FULL_BYTES);
}
// [4] blockNumber
this.blockNumber = bb.getInt();
if (blockNumber < 0) throw new IllegalArgumentException("blockNumber < 0: " + blockNumber);
this.timestamp = bb.getLong();
long now = Instant.now().getEpochSecond();
if (timestamp > now + MAX_FUTURE_SECONDS) {
throw new IllegalArgumentException("timestamp is too far in future: ts=" + timestamp + " now=" + now);
if (this.blockNumber < 0) {
throw new IllegalArgumentException("blockNumber < 0: " + this.blockNumber);
}
// [8] timestamp
this.timestamp = bb.getLong();
// запрет “в будущее” больше чем на 1 минуту
long now = Instant.now().getEpochSecond();
if (this.timestamp > now + MAX_FUTURE_SECONDS) {
throw new IllegalArgumentException("timestamp is too far in future: ts=" + this.timestamp
+ " now=" + now + " maxFutureSec=" + MAX_FUTURE_SECONDS);
}
// [2][2][2] type/subType/version
this.type = bb.getShort();
this.subType = bb.getShort();
this.version = bb.getShort();
this.bodyBytes = new byte[bb.remaining()];
bb.get(bodyBytes);
this.body = BodyRecordParser.parse(type, subType, version, bodyBytes);
this.hash32 = BchCryptoVerifier.sha256(frameBytes);
// [N] bodyBytes
int bodyLen = blockSize - PREIMAGE_HEADER_SIZE;
if (bodyLen < 0) {
throw new IllegalArgumentException("Invalid body length: " + bodyLen);
}
this.bodyBytes = new byte[bodyLen];
bb.get(this.bodyBytes);
// TAIL: [2] sigMarker
this.sigMarker = Short.toUnsignedInt(bb.getShort());
if (this.sigMarker != SIG_MARKER_ED25519) {
throw new IllegalArgumentException(String.format(
"Bad sigMarker: 0x%04X (expected 0x%04X)", this.sigMarker, SIG_MARKER_ED25519
));
}
// TAIL: [64] signature64
this.signature64 = new byte[SIGNATURE_LEN];
bb.get(this.signature64);
// preimage = первые blockSize байт (включая frameCode)
this.preimage = Arrays.copyOfRange(fullBytes, 0, blockSize);
// hash32 = sha256(preimage)
this.hash32 = BchCryptoVerifier.sha256(preimage);
// parse body по header.type/subType/version + ОБЯЗАТЕЛЬНЫЙ check()
this.body = BodyRecordParser.parse(this.type, this.subType, this.version, this.bodyBytes);
this.fullBytes = Arrays.copyOf(fullBytes, fullBytes.length);
if (bb.remaining() != 0) {
throw new IllegalArgumentException("Unexpected tail bytes, remaining=" + bb.remaining());
}
}
public Ans104DataItem getDataItem() { return dataItem; }
public byte[] getFrameBytes() { return Arrays.copyOf(frameBytes, frameBytes.length); }
/** Kept as an alias for code/docs that called the old field preimage. */
public byte[] getPreimageBytes() { return getFrameBytes(); }
public byte[] getSignature64() { return dataItem.signature64(); }
public byte[] getOwner32() { return dataItem.owner32(); }
public byte[] getDataItemId32() { return dataItem.id32(); }
public byte[] getHash32() { return Arrays.copyOf(hash32, hash32.length); }
/** Full serialized ANS-104 DataItem. */
public byte[] toBytes() { return dataItem.rawBytes(); }
/* ===================================================================== */
/* ====================== Конструктор сборки ============================ */
/* ===================================================================== */
public BchBlockEntry(byte[] prevHash32,
int blockNumber,
long timestamp,
short type,
short subType,
short version,
byte[] bodyBytes,
byte[] signature64) {
Objects.requireNonNull(prevHash32, "prevHash32 == null");
Objects.requireNonNull(bodyBytes, "bodyBytes == null");
Objects.requireNonNull(signature64, "signature64 == null");
if (prevHash32.length != 32) throw new IllegalArgumentException("prevHash32 != 32");
if (signature64.length != SIGNATURE_LEN) throw new IllegalArgumentException("signature64 != 64");
if (blockNumber < 0) {
throw new IllegalArgumentException("blockNumber < 0: " + blockNumber);
}
// запрет “в будущее” больше чем на 1 минуту
long now = Instant.now().getEpochSecond();
if (timestamp > now + MAX_FUTURE_SECONDS) {
throw new IllegalArgumentException("timestamp is too far in future: ts=" + timestamp
+ " now=" + now + " maxFutureSec=" + MAX_FUTURE_SECONDS);
}
this.frameCode = FRAME_CODE_V0;
this.prevHash32 = Arrays.copyOf(prevHash32, 32);
this.blockNumber = blockNumber;
this.timestamp = timestamp;
this.type = type;
this.subType = subType;
this.version = version;
this.bodyBytes = Arrays.copyOf(bodyBytes, bodyBytes.length);
// blockSize = размер preimage (включая frameCode)
this.blockSize = PREIMAGE_HEADER_SIZE + this.bodyBytes.length;
int fullLen = this.blockSize + SIG_MARKER_LEN + SIGNATURE_LEN;
if (fullLen > MAX_BLOCK_FULL_BYTES) {
throw new IllegalArgumentException("Block too large: " + fullLen + " > " + MAX_BLOCK_FULL_BYTES);
}
// parse body по header + ОБЯЗАТЕЛЬНЫЙ check()
this.body = BodyRecordParser.parse(this.type, this.subType, this.version, this.bodyBytes);
// tail marker фиксирован
this.sigMarker = SIG_MARKER_ED25519;
this.signature64 = Arrays.copyOf(signature64, SIGNATURE_LEN);
// build preimage
ByteBuffer pre = ByteBuffer.allocate(blockSize).order(ByteOrder.BIG_ENDIAN);
pre.putShort((short) (FRAME_CODE_V0 & 0xFFFF));
pre.put(this.prevHash32);
pre.putInt(this.blockSize);
pre.putInt(this.blockNumber);
pre.putLong(this.timestamp);
pre.putShort(this.type);
pre.putShort(this.subType);
pre.putShort(this.version);
pre.put(this.bodyBytes);
this.preimage = pre.array();
this.hash32 = BchCryptoVerifier.sha256(preimage);
// build fullBytes: preimage + sigMarker + signature64
ByteBuffer full = ByteBuffer.allocate(fullLen).order(ByteOrder.BIG_ENDIAN);
full.put(this.preimage);
full.putShort((short) (SIG_MARKER_ED25519 & 0xFFFF));
full.put(this.signature64);
this.fullBytes = full.array();
}
/* ===================================================================== */
/* ============================ Getters ================================= */
/* ===================================================================== */
public byte[] getPreimageBytes() {
return Arrays.copyOf(preimage, preimage.length);
}
/** Возвращает подпись Ed25519 (64 байта). */
public byte[] getSignature64() {
return Arrays.copyOf(signature64, SIGNATURE_LEN);
}
/** Возвращает hash32 = SHA-256(preimage). */
public byte[] getHash32() {
return Arrays.copyOf(hash32, HASH_LEN);
}
/** Возвращает полный блок: preimage + sigMarker + signature. */
public byte[] toBytes() {
return Arrays.copyOf(fullBytes, fullBytes.length);
}
@Override
public String toString() {
return "BchBlockEntry{" +
"frameCode=0x" + Integer.toHexString(frameCode) +
", blockNumber=" + blockNumber +
", timestamp=" + timestamp +
", type=" + (type & 0xffff) +
", subType=" + (subType & 0xffff) +
", version=" + (version & 0xffff) +
", bodyLen=" + bodyBytes.length +
", dataItemId=" + toHex(getDataItemId32()) +
", blockHash=" + toHex(hash32) +
'}';
String timeIso;
try {
timeIso = Instant.ofEpochSecond(timestamp).toString();
} catch (Exception e) {
timeIso = "некорректныйTimestamp";
}
return "BchBlockEntry{"
+ "FRAME{frameCode=0x" + hex4(frameCode)
+ "}, HDR{"
+ "blockSize=" + blockSize
+ ", blockNumber=" + blockNumber
+ ", timestamp=" + timestamp + " (" + timeIso + ")"
+ ", type=" + (type & 0xFFFF)
+ ", subType=" + (subType & 0xFFFF)
+ ", version=" + (version & 0xFFFF)
+ ", prevHash32(hex)=" + toHex(prevHash32)
+ "}"
+ ", BODY{len=" + (bodyBytes == null ? -1 : bodyBytes.length) + "}"
+ ", TAIL{sigMarker=0x" + hex4(sigMarker) + ", signature64(hex)=" + toHex(signature64) + "}"
+ ", DERIVED{hash32(hex)=" + toHex(hash32) + "}"
+ "}";
}
private static String hex4(int v) {
String s = Integer.toHexString(v & 0xFFFF);
while (s.length() < 4) s = "0" + s;
return s;
}
private static String toHex(byte[] bytes) {
char[] h = "0123456789abcdef".toCharArray();
if (bytes == null) return "null";
char[] HEX = "0123456789abcdef".toCharArray();
char[] out = new char[bytes.length * 2];
for (int i = 0; i < bytes.length; i++) {
int v = bytes[i] & 0xff;
out[i * 2] = h[v >>> 4]; out[i * 2 + 1] = h[v & 15];
int vv = bytes[i] & 0xFF;
out[i * 2] = HEX[vv >>> 4];
out[i * 2 + 1] = HEX[vv & 0x0F];
}
return new String(out);
}
}
}
@@ -1,27 +1,42 @@
package blockchain;
import utils.crypto.Ed25519Util;
import java.security.MessageDigest;
import java.util.Objects;
/** Cryptographic checks for SHiNE Frame v1 + surrounding ANS-104 DataItem. */
/**
* Верификатор SHiNE (Frame v0):
*
* preimage = первые blockSize байт блока (ВКЛЮЧАЯ frameCode=0x0000),
* = всё до TAIL (sigMarker+signature).
*
* hash32 = SHA-256(preimage)
* verify = Ed25519.verify(hash32, signature64, pubKey32)
*/
public final class BchCryptoVerifier {
private BchCryptoVerifier() {}
public static byte[] sha256(byte[] data) {
Objects.requireNonNull(data, "data == null");
try { return MessageDigest.getInstance("SHA-256").digest(data); }
catch (Exception e) { throw new IllegalStateException("SHA-256 unavailable", e); }
try {
MessageDigest d = MessageDigest.getInstance("SHA-256");
return d.digest(data);
} catch (Exception e) {
throw new IllegalStateException("SHA-256 unavailable", e);
}
}
/**
* Verifies that the ANS-104 owner is the current blockchain key and that the
* ANS-104 Ed25519 signature is valid. The SHiNE block hash itself remains
* SHA-256(Frame v1 bytes) and is intentionally independent of Arweave.
*/
public static boolean verifyBlock(BchBlockEntry block, byte[] publicKey32) {
Objects.requireNonNull(block, "block == null");
Objects.requireNonNull(publicKey32, "publicKey32 == null");
if (publicKey32.length != 32) throw new IllegalArgumentException("publicKey32 != 32");
return block.getDataItem().ownerEquals(publicKey32) && block.getDataItem().verifySignature();
byte[] hash32 = block.getHash32();
byte[] sig64 = block.getSignature64();
return Ed25519Util.verify(hash32, sig64, publicKey32);
}
}
}
@@ -25,10 +25,6 @@ public final class BodyRecordParser {
&& (v == (CreateChannelBody.VER & 0xFFFF))) {
return new CreateChannelBody(subType, version, bodyBytes).check();
}
if (st == (ForkBody.SUBTYPE & 0xFFFF)
&& (v == (ForkBody.VER & 0xFFFF))) {
return new ForkBody(subType, version, bodyBytes).check();
}
throw new IllegalArgumentException(
String.format("Unknown TECH body type/version/subType: type=%d ver=%d subType=%d", t, v, st)
);
@@ -37,7 +33,7 @@ public final class BodyRecordParser {
int key = (t << 16) | v;
BodyRecord r = switch (key) {
case TextLineBody.KEY -> {
case TextBody.KEY -> {
if (st == (MsgSubType.TEXT_POST & 0xFFFF)
|| st == (MsgSubType.TEXT_EDIT_POST & 0xFFFF)
|| st == (MsgSubType.TEXT_EXERCISE & 0xFFFF)
@@ -45,8 +41,7 @@ public final class BodyRecordParser {
|| st == (MsgSubType.TEXT_COURSE & 0xFFFF)
|| st == (MsgSubType.TEXT_ENTRYPOINT & 0xFFFF)
|| st == (MsgSubType.TEXT_REPOST & 0xFFFF)
|| st == (MsgSubType.TEXT_CHANNEL_META & 0xFFFF)
|| st == (MsgSubType.TEXT_CHANNEL_DELETE & 0xFFFF)) {
|| st == (MsgSubType.TEXT_CHANNEL_META & 0xFFFF)) {
yield new TextLineBody(subType, version, bodyBytes);
}
@@ -13,5 +13,5 @@
// public static final short TEXT = 1; // сообщения да надо
// public static final short REACTION = 2; // реакции не надо
// public static final short CONNECTION = 3; // связи (friend/contact/follow) да надо
// public static final short USER_PROFILE= 4; // профиль пользователя да надо
// public static final short USER_PARAM = 4; // параметры профиля да надо
//}
@@ -35,8 +35,6 @@ public final class MsgSubType {
/** HeaderBody: subType всегда 0 (compat). */
public static final short HEADER_COMPAT = 0;
public static final short TECH_CREATE_CHANNEL = 1;
/** Новый fork/ротация ключей: ссылка на родительскую цепочку и точку отката. */
public static final short TECH_FORK = 2;
/* ===================== TEXT (msg_type=1) ===================== */
@@ -55,7 +53,7 @@ public final class MsgSubType {
/**
* REPLY — ответ на сообщение.
* НЕ в линии. Имеет target (toLogin + blockNumber + hash32).
* НЕ в линии. Имеет target (toBlockchainName + blockNumber + hash32).
* Может указывать на чужой блокчейн/чужую линию/чужой канал.
*/
public static final short TEXT_REPLY = 20;
@@ -71,7 +69,7 @@ public final class MsgSubType {
/**
* REPOST — отложенная будущая заготовка репоста сообщения в линии канала.
* Имеет hasLine + target (toLogin + toBlockGlobalNumber + toBlockHash32) + текст комментария.
* Имеет hasLine + target (toBlockchainName + toBlockGlobalNumber + toBlockHash32) + текст комментария.
*/
public static final short TEXT_REPOST = 50;
@@ -81,9 +79,6 @@ public final class MsgSubType {
*/
public static final short TEXT_CHANNEL_META = 90;
/** CHANNEL_DELETE — soft-delete marker for a channel line. */
public static final short TEXT_CHANNEL_DELETE = 92;
/** ENTRYPOINT — входная страница канала (line-based). */
public static final short TEXT_ENTRYPOINT = 100;
/** EXERCISE — упражнение/комплекс (line-based). */
@@ -107,23 +102,16 @@ public final class MsgSubType {
/** Удалить из близких друзей (close friend). */
public static final short CONNECTION_UNCLOSE_FRIEND = 11;
/** Добавить в друзья. */
public static final short CONNECTION_FRIEND = 14;
/** Удалить из друзей. */
public static final short CONNECTION_UNFRIEND = 15;
/** Добавить в контакты. */
public static final short CONNECTION_CONTACT = 20;
/** Удалить из контактов. */
public static final short CONNECTION_UNCONTACT = 21;
// FOLLOW на публичный канал используется. Старый FOLLOW пользователя (target header/block 0) считается legacy. DO NOT REMOVE.
/** Подписаться (follow). */
public static final short CONNECTION_FOLLOW = 30;
/** Отписаться (unfollow). */
public static final short CONNECTION_UNFOLLOW = 31;
// Родственные связи пока не используются в UI. Сохраняем коды. DO NOT REMOVE.
/** Добавить связь "жена/муж". */
public static final short CONNECTION_SPOUSE = 40;
/** Удалить связь "жена/муж". */
@@ -144,8 +132,9 @@ public final class MsgSubType {
/** Удалить связь "брат/сестра". */
public static final short CONNECTION_UNSIBLING = 55;
// Legacy. Допускаем старые блоки 60/61, но новый UI их не создаёт и не использует. DO NOT REMOVE.
/** Просто знаю этого человека. */
public static final short CONNECTION_KNOWN_PERSON = 60;
/** Не знаю этого человека. */
public static final short CONNECTION_UNKNOWN_PERSON = 61;
/** Точно уверен, что сияющий. */
@@ -153,17 +142,11 @@ public final class MsgSubType {
/** Не подтверждаю, что сияющий. */
public static final short CONNECTION_SHINE_UNCONFIRMED = 71;
// Пока не используется в UI. Сохраняем для совместимости протокола/блокчейна. DO NOT REMOVE.
/** Мало знаком, но видел сияющим. */
public static final short CONNECTION_SHINE_SEEN = 74;
/** Не отмечаю, что видел сияющим. */
public static final short CONNECTION_SHINE_UNSEEN = 75;
/** Подтверждаю, что это действительно официальный аккаунт этого человека. */
public static final short CONNECTION_OFFICIAL_ACCOUNT_CONFIRMED = 80;
/** Снимаю подтверждение официального аккаунта этого человека. */
public static final short CONNECTION_OFFICIAL_ACCOUNT_UNCONFIRMED = 81;
/* ===================== USER_PARAM (msg_type=4) ===================== */
/** Параметр профиля key/value (обе строки). */
@@ -1,17 +0,0 @@
package blockchain;
/**
* Канонические ANS-104 tag names/value текущего SHiNE transport namespace на сервере.
*
* При смене тестовой эпохи namespace меняется отдельно в трёх рабочих местах:
* сервер, UI и актуальный Arweave Viewer.
*/
public final class ShineProtocolTags {
private ShineProtocolTags() {}
public static final String NAMESPACE = "test5592";
public static final String APP_TAG_NAME = "App";
public static final String APP_TAG_VALUE = NAMESPACE;
public static final String CHANNEL_TAG_NAME = "c";
public static final String TYPE_TAG_NAME = "t";
}
@@ -1,23 +1,21 @@
package blockchain.body;
/**
* BodyHasLine — типы блоков, которые входят в проверяемую логическую линию.
* BodyHasLine — для типов, которые имеют линейные поля в body.
*
* Общая семантика:
* prevLineBlockGlobalNumber — GLOBAL blockNumber предыдущего блока этой линии;
* prevLineBlockHash32 — hash32 предыдущего блока этой линии;
* lineSeq — порядковый номер шага линии.
* Line-prefix (BigEndian) в НАЧАЛЕ bodyBytes:
* [4] lineCode код линии (root-идентификатор):
* - 0 для дефолтной линии/канала "0" (root = HEADER, blockNumber=0)
* - для канала "X": blockNumber root-блока канала (CREATE_CHANNEL)
*
* lineCode — логический идентификатор линии:
* - 0 для фиксированных системных линий (TECH, CONNECTION, USER_PROFILE)
* и для дефолтного канала, корнем которого является HEADER #0;
* - для пользовательского канала: GLOBAL blockNumber его CREATE_CHANNEL root.
* [4] prevLineBlockGlobalNumber глобальный номер предыдущего блока в этой линии
* [32] prevLineBlockHash32 hash32 предыдущего блока в этой линии
*
* Важно: lineCode не обязан физически присутствовать в body. Для фиксированных
* USER_PROFILE и CONNECTION он выводится из msg_type и метод lineCode() возвращает 0.
* Для TEXT-каналов и TECH-блоков lineCode хранится в body явно.
* [4] lineSeq порядковый номер сообщения внутри линии (1..N)
*
* Полная проверка хвоста линии, prev hash и lineSeq выполняется сервером при AddBlock.
* Важно:
* - Проверка связности линии (prevLineBlockGlobalNumber ↔ prevLineBlockHash32) и корректности lineSeq
* выполняется на сервере/в БД при вставке (а не в body.check()).
*/
public interface BodyHasLine {
@@ -28,4 +26,4 @@ public interface BodyHasLine {
byte[] prevLineBlockHash32();
int lineSeq();
}
}
@@ -1,25 +1,31 @@
package blockchain.body;
import utils.blockchain.BlockchainNameUtil;
/**
* Body that refers to a logical block target.
* BodyHasTarget — дополнительный интерфейс для body, которые "ссылаются" на цель (to-поля).
*
* Canonical rules:
* - external target: login + forkNumber + blockNumber + blockHash;
* - own EDIT target: blockNumber + blockHash only;
* - logical identity NEVER includes forkNumber: login + blockNumber + blockHash;
* - forkNumber is informational/historical only and must be in 1..999.
* Новое правило:
* - toLogin НЕ храним в байтах блока.
* - toLogin всегда вычисляется из toBchName по стандарту login+"-NNN".
*
* Все методы могут возвращать null.
*/
public interface BodyHasTarget {
/** Target login; null for own-chain compact EDIT targets. */
default String toLogin() { return null; }
/** Historical fork number recorded by the author; null for compact EDIT targets. */
default Integer toForkNumber() { return null; }
/** login цели (nullable). Вычисляется из toBchName(). */
default String toLogin() {
String bch = toBchName();
if (bch == null) return null;
return BlockchainNameUtil.loginFromBlockchainName(bch);
}
/** Runtime-only physical blockchain cache; never serialized in canonical targets. */
@Deprecated
default String toBchName() { return null; }
/** blockchainName цели (nullable). */
String toBchName();
/** globalNumber цели (nullable). */
Integer toBlockGlobalNumber();
/** hash целевого блока (обычно 32 байта). Может быть null, если ссылки нет. */
byte[] toBlockHashBytes();
}
}
@@ -1,115 +0,0 @@
package blockchain.body;
import java.nio.ByteBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.CodingErrorAction;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
/** Shared codec/validation for canonical SHiNE target formats. */
final class BodyTargetSupport {
private BodyTargetSupport() {}
record ExternalTarget(String login, int forkNumber, int blockNumber, byte[] blockHash32) {}
static ExternalTarget readExternal(ByteBuffer bb, String ctx, int bytesRequiredAfterTarget) {
ensureMin(bb, 1 + 1 + 2 + 4 + 32 + bytesRequiredAfterTarget, ctx + " target too short");
int loginLen = Byte.toUnsignedInt(bb.get());
if (loginLen <= 0) throw new IllegalArgumentException(ctx + " toLoginLen is 0");
ensureMin(bb, loginLen + 2 + 4 + 32 + bytesRequiredAfterTarget, ctx + " target payload too short");
byte[] loginBytes = new byte[loginLen];
bb.get(loginBytes);
String login = decodeStrictUtf8(loginBytes, ctx + " toLogin");
if (login.isBlank()) throw new IllegalArgumentException(ctx + " toLogin is blank");
int forkNumber = Short.toUnsignedInt(bb.getShort());
validateForkNumber(forkNumber, ctx);
int blockNumber = bb.getInt();
if (blockNumber < 0) throw new IllegalArgumentException(ctx + " toBlockGlobalNumber < 0");
byte[] hash = new byte[32];
bb.get(hash);
requireNonZeroHash32(hash, ctx + " toBlockHash32");
return new ExternalTarget(login, forkNumber, blockNumber, hash);
}
static int externalSize(String login) {
return 1 + loginBytes(login).length + 2 + 4 + 32;
}
static void writeExternal(ByteBuffer bb, String login, int forkNumber, int blockNumber, byte[] hash32, String ctx) {
byte[] loginBytes = loginBytes(login);
validateForkNumber(forkNumber, ctx);
if (blockNumber < 0) throw new IllegalArgumentException(ctx + " toBlockGlobalNumber < 0");
requireNonZeroHash32(hash32, ctx + " toBlockHash32");
bb.put((byte) loginBytes.length);
bb.put(loginBytes);
bb.putShort((short) forkNumber);
bb.putInt(blockNumber);
bb.put(hash32);
}
static void validateExternal(String login, Integer forkNumber, Integer blockNumber, byte[] hash32, String ctx) {
loginBytes(login);
if (forkNumber == null) throw new IllegalArgumentException(ctx + " toForkNumber is null");
validateForkNumber(forkNumber, ctx);
if (blockNumber == null || blockNumber < 0) throw new IllegalArgumentException(ctx + " toBlockGlobalNumber invalid");
requireNonZeroHash32(hash32, ctx + " toBlockHash32");
}
static void validateCompact(Integer blockNumber, byte[] hash32, String ctx) {
if (blockNumber == null || blockNumber < 0) throw new IllegalArgumentException(ctx + " toBlockGlobalNumber invalid");
requireNonZeroHash32(hash32, ctx + " toBlockHash32");
}
static byte[] readCompactHash(ByteBuffer bb, String ctx) {
ensureMin(bb, 4 + 32, ctx + " target too short");
int blockNumber = bb.getInt();
if (blockNumber < 0) throw new IllegalArgumentException(ctx + " toBlockGlobalNumber < 0");
byte[] hash = new byte[32];
bb.get(hash);
requireNonZeroHash32(hash, ctx + " toBlockHash32");
return hash;
}
static byte[] loginBytes(String login) {
if (login == null || login.isBlank()) throw new IllegalArgumentException("toLogin is blank");
byte[] bytes = login.getBytes(StandardCharsets.UTF_8);
if (bytes.length == 0 || bytes.length > 255) throw new IllegalArgumentException("toLogin utf8 len must be 1..255");
return bytes;
}
static void validateForkNumber(int forkNumber, String ctx) {
if (forkNumber < 1 || forkNumber > 999) {
throw new IllegalArgumentException(ctx + " toForkNumber must be 1..999");
}
}
static void requireNonZeroHash32(byte[] hash32, String field) {
if (hash32 == null || hash32.length != 32) throw new IllegalArgumentException(field + " must be 32 bytes");
boolean any = false;
for (byte b : hash32) any |= b != 0;
if (!any) throw new IllegalArgumentException(field + " must not be zero hash");
}
static byte[] copyHash(byte[] hash32) {
return hash32 == null ? null : Arrays.copyOf(hash32, 32);
}
static String decodeStrictUtf8(byte[] bytes, String field) {
var decoder = StandardCharsets.UTF_8.newDecoder()
.onMalformedInput(CodingErrorAction.REPORT)
.onUnmappableCharacter(CodingErrorAction.REPORT);
try {
return decoder.decode(ByteBuffer.wrap(bytes)).toString();
} catch (CharacterCodingException e) {
throw new IllegalArgumentException(field + " is not valid UTF-8", e);
}
}
static void ensureMin(ByteBuffer bb, int need, String msg) {
if (bb.remaining() < need) throw new IllegalArgumentException(msg + " (need=" + need + ", remaining=" + bb.remaining() + ")");
}
}
@@ -1,104 +1,280 @@
package blockchain.body;
import blockchain.MsgSubType;
import utils.blockchain.BlockchainNameUtil;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Objects;
/**
* CONNECTION with one fixed connection-history line and canonical external target.
* lineCode is not stored in body: the logical connection line always has code 0.
* ConnectionBody — type=3, ver=1 (в заголовке блока).
*
* subType (в заголовке блока) как MsgSubType:
* FRIEND=10, UNFRIEND=11
* CONTACT=20, UNCONTACT=21
* FOLLOW=30, UNFOLLOW=31
* SPOUSE=40, UNSPOUSE=41
* PARENT=50, UNPARENT=51
* CHILD=52, UNCHILD=53
* SIBLING=54, UNSIBLING=55
* KNOWN_PERSON=60, UNKNOWN_PERSON=61
* SHINE_CONFIRMED=70, SHINE_UNCONFIRMED=71
* SHINE_SEEN=74, SHINE_UNSEEN=75
*
* bodyBytes (BigEndian), новый формат (toLogin НЕ ХРАНИМ):
* [4] lineCode
* [4] prevLineNumber
* [32] prevLineHash32
* [4] thisLineNumber
*
* [1] toBlockchainNameLen (uint8)
* [N] toBlockchainName UTF-8
* [4] toBlockGlobalNumber (int32)
* [32] toBlockHash32 (raw 32 bytes)
*
* toLogin вычисляется автоматически из toBlockchainName:
* toLogin = BlockchainNameUtil.loginFromBlockchainName(toBlockchainName)
*/
/**
* =========================================================================
* ПРАВИЛО TARGET/ROOT ДЛЯ КАНАЛОВ И СВЯЗЕЙ (важно для подписок/друзей/контактов)
* =========================================================================
*
* Термины:
* - ROOT линии/канала = блок, который "начинает" линию:
* * для канала "0" root = HEADER (blockNumber=0)
* * для канала "X" root = CREATE_CHANNEL (blockNumber этого блока)
*
* 1) СВЯЗИ МЕЖДУ ПОЛЬЗОВАТЕЛЯМИ (CONNECTION_*):
* FRIEND / CONTACT -> цель ВСЕГДА HEADER пользователя:
* toBlockNumber = 0
* toBlockHash32 = hash32(HEADER цели)
*
* 2) ПОДПИСКИ НА КОНТЕНТ (FOLLOW/SUBSCRIBE):
* FOLLOW пользователя (в целом) -> цель = ROOT дефолтного канала "0" (то есть HEADER):
* toBlockNumber = 0
* toBlockHash32 = hash32(HEADER цели)
*
* FOLLOW/подписка на конкретный канал пользователя ->
* цель = ROOT этого канала:
* - канал "0": toBlockNumber=0, toBlockHash32=hash32(HEADER)
* - канал "X": toBlockNumber=blockNumber(CREATE_CHANNEL),
* toBlockHash32=hash32(CREATE_CHANNEL)
*
* 3) ЗАПРЕТЫ ВАЛИДАЦИИ (желательно на сервере/в БД):
* - CONNECTION_CLOSE_FRIEND/CONTACT не могут ссылаться на не-HEADER (toBlockNumber != 0 запрещено).
* - FOLLOW на канал "X" не может ссылаться на произвольный пост внутри канала:
* разрешено ТОЛЬКО на ROOT (HEADER или CREATE_CHANNEL).
*
* Зачем так:
* - связи и подписки всегда стабильны и не ломаются при новых постах,
* - один понятный инвариант: "подписка всегда указывает на root линии".
* =========================================================================
*/
public final class ConnectionBody implements BodyRecord, BodyHasTarget, BodyHasLine {
public static final short TYPE = 3;
public static final short VER = 1;
public static final short VER = 1;
public static final int KEY = ((TYPE & 0xFFFF) << 16) | (VER & 0xFFFF);
public final short subType;
public final short version;
public final int prevConnectionBlockNumber;
public final byte[] prevConnectionBlockHash32;
public final int connectionSequence;
public final String toLogin;
public final int toForkNumber;
public final short subType; // из header
public final short version; // из header
// line
public final int lineCode;
public final int prevLineNumber;
public final byte[] prevLineHash32;
public final int thisLineNumber;
// payload
public final String toBlockchainName;
public final int toBlockGlobalNumber;
public final byte[] toBlockHash32;
public ConnectionBody(short subType, short version, byte[] bodyBytes) {
Objects.requireNonNull(bodyBytes, "bodyBytes == null");
this.subType = subType;
this.version = version;
if ((version & 0xFFFF) != 1 || !isValidSubType(subType)) throw new IllegalArgumentException("Bad Connection header");
if ((this.version & 0xFFFF) != (VER & 0xFFFF)) {
throw new IllegalArgumentException("ConnectionBody version must be 1, got=" + (this.version & 0xFFFF));
}
if (!isValidSubType(this.subType)) {
throw new IllegalArgumentException("Bad connection subType: " + (this.subType & 0xFFFF));
}
// минимум:
// lineCode(4) + line(4+32+4) + toBchLen[1]+toBch[1] + global[4] + hash[32]
if (bodyBytes.length < 4 + (4 + 32 + 4) + 1 + 1 + 4 + 32) {
throw new IllegalArgumentException("ConnectionBody too short");
}
ByteBuffer bb = ByteBuffer.wrap(bodyBytes).order(ByteOrder.BIG_ENDIAN);
BodyTargetSupport.ensureMin(bb, 4 + 32 + 4 + 1 + 1 + 2 + 4 + 32, "ConnectionBody too short");
this.prevConnectionBlockNumber = bb.getInt();
this.prevConnectionBlockHash32 = new byte[32];
bb.get(this.prevConnectionBlockHash32);
this.connectionSequence = bb.getInt();
BodyTargetSupport.ExternalTarget t = BodyTargetSupport.readExternal(bb, "CONNECTION", 0);
this.toLogin = t.login();
this.toForkNumber = t.forkNumber();
this.toBlockGlobalNumber = t.blockNumber();
this.toBlockHash32 = t.blockHash32();
if (bb.hasRemaining()) throw new IllegalArgumentException("Unexpected ConnectionBody tail");
this.lineCode = bb.getInt();
this.prevLineNumber = bb.getInt();
this.prevLineHash32 = new byte[32];
bb.get(this.prevLineHash32);
this.thisLineNumber = bb.getInt();
int bchLen = Byte.toUnsignedInt(bb.get());
if (bchLen <= 0) throw new IllegalArgumentException("toBlockchainNameLen is 0");
if (bb.remaining() < bchLen + 4 + 32) throw new IllegalArgumentException("Connection payload too short");
byte[] bchBytes = new byte[bchLen];
bb.get(bchBytes);
this.toBlockchainName = new String(bchBytes, StandardCharsets.UTF_8);
this.toBlockGlobalNumber = bb.getInt();
this.toBlockHash32 = new byte[32];
bb.get(this.toBlockHash32);
if (bb.remaining() != 0) throw new IllegalArgumentException("Unexpected tail bytes, remaining=" + bb.remaining());
}
public ConnectionBody(int prevConnectionBlockNumber, byte[] prevConnectionBlockHash32, int connectionSequence, short subType,
String toLogin, int toForkNumber, int toBlockGlobalNumber, byte[] toBlockHash32) {
if (!isValidSubType(subType)) throw new IllegalArgumentException("Bad connection fields");
BodyTargetSupport.validateExternal(toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "CONNECTION");
this.prevConnectionBlockNumber = prevConnectionBlockNumber;
this.prevConnectionBlockHash32 = prevConnectionBlockHash32 == null ? new byte[32] : Arrays.copyOf(prevConnectionBlockHash32, 32);
this.connectionSequence = connectionSequence;
public ConnectionBody(int lineCode,
int prevLineNumber,
byte[] prevLineHash32,
int thisLineNumber,
short subType,
String toBlockchainName,
int toBlockGlobalNumber,
byte[] toBlockHash32) {
Objects.requireNonNull(toBlockchainName, "toBlockchainName == null");
Objects.requireNonNull(toBlockHash32, "toBlockHash32 == null");
if (lineCode < 0) throw new IllegalArgumentException("lineCode < 0");
if (!isValidSubType(subType)) throw new IllegalArgumentException("Bad connection subType: " + (subType & 0xFFFF));
if (toBlockchainName.isBlank()) throw new IllegalArgumentException("toBlockchainName is blank");
// Железное правило формата: bchName -> login + "-NNN"
if (BlockchainNameUtil.loginFromBlockchainName(toBlockchainName) == null) {
throw new IllegalArgumentException("toBlockchainName must match login+\"-NNN\": " + toBlockchainName);
}
if (toBlockGlobalNumber < 0) throw new IllegalArgumentException("toBlockGlobalNumber < 0");
if (toBlockHash32.length != 32) throw new IllegalArgumentException("toBlockHash32 != 32");
this.lineCode = lineCode;
this.prevLineNumber = prevLineNumber;
this.prevLineHash32 = (prevLineHash32 == null ? new byte[32] : Arrays.copyOf(prevLineHash32, 32));
this.thisLineNumber = thisLineNumber;
this.subType = subType;
this.version = VER;
this.toLogin = toLogin;
this.toForkNumber = toForkNumber;
this.toBlockchainName = toBlockchainName;
this.toBlockGlobalNumber = toBlockGlobalNumber;
this.toBlockHash32 = Arrays.copyOf(toBlockHash32, 32);
}
@Override public ConnectionBody check() {
if (!isValidSubType(subType)) throw new IllegalArgumentException("Bad connection fields");
if (prevConnectionBlockNumber < 0) throw new IllegalArgumentException("prevConnectionBlockNumber must be >=0");
if (prevConnectionBlockHash32 == null || prevConnectionBlockHash32.length != 32) throw new IllegalArgumentException("prevConnectionBlockHash32 invalid");
if (connectionSequence <= 0) throw new IllegalArgumentException("connectionSequence must be >=1");
BodyTargetSupport.validateExternal(toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "CONNECTION");
private static boolean isValidSubType(short st) {
int v = st & 0xFFFF;
return v == (MsgSubType.CONNECTION_CLOSE_FRIEND & 0xFFFF)
|| v == (MsgSubType.CONNECTION_UNCLOSE_FRIEND & 0xFFFF)
|| v == (MsgSubType.CONNECTION_CONTACT & 0xFFFF)
|| v == (MsgSubType.CONNECTION_UNCONTACT & 0xFFFF)
|| v == (MsgSubType.CONNECTION_FOLLOW & 0xFFFF)
|| v == (MsgSubType.CONNECTION_UNFOLLOW & 0xFFFF)
|| v == (MsgSubType.CONNECTION_SPOUSE & 0xFFFF)
|| v == (MsgSubType.CONNECTION_UNSPOUSE & 0xFFFF)
|| v == (MsgSubType.CONNECTION_PARENT & 0xFFFF)
|| v == (MsgSubType.CONNECTION_UNPARENT & 0xFFFF)
|| v == (MsgSubType.CONNECTION_CHILD & 0xFFFF)
|| v == (MsgSubType.CONNECTION_UNCHILD & 0xFFFF)
|| v == (MsgSubType.CONNECTION_SIBLING & 0xFFFF)
|| v == (MsgSubType.CONNECTION_UNSIBLING & 0xFFFF)
|| v == (MsgSubType.CONNECTION_KNOWN_PERSON & 0xFFFF)
|| v == (MsgSubType.CONNECTION_UNKNOWN_PERSON & 0xFFFF)
|| v == (MsgSubType.CONNECTION_SHINE_CONFIRMED & 0xFFFF)
|| v == (MsgSubType.CONNECTION_SHINE_UNCONFIRMED & 0xFFFF)
|| v == (MsgSubType.CONNECTION_SHINE_SEEN & 0xFFFF)
|| v == (MsgSubType.CONNECTION_SHINE_UNSEEN & 0xFFFF);
}
@Override
public ConnectionBody check() {
if (lineCode < 0) throw new IllegalArgumentException("lineCode < 0");
if (!isValidSubType(subType)) throw new IllegalArgumentException("Bad connection subType: " + (subType & 0xFFFF));
// line rule (как было)
if (prevLineNumber == -1) {
if (!isAllZero32(prevLineHash32)) throw new IllegalArgumentException("prevLineHash32 must be zero when prevLineNumber=-1");
if (thisLineNumber != -1) throw new IllegalArgumentException("thisLineNumber must be -1 when prevLineNumber=-1");
} else {
if (prevLineHash32 == null || prevLineHash32.length != 32) throw new IllegalArgumentException("prevLineHash32 invalid");
}
if (toBlockchainName == null || toBlockchainName.isBlank())
throw new IllegalArgumentException("toBlockchainName is blank");
// гарантируем вычислимый toLogin (иначе target “битый” по стандарту)
if (BlockchainNameUtil.loginFromBlockchainName(toBlockchainName) == null)
throw new IllegalArgumentException("toBlockchainName must match login+\"-NNN\": " + toBlockchainName);
if (toBlockGlobalNumber < 0) throw new IllegalArgumentException("toBlockGlobalNumber < 0");
if (toBlockHash32 == null || toBlockHash32.length != 32) throw new IllegalArgumentException("toBlockHash32 invalid");
return this;
}
@Override public byte[] toBytes() {
check();
ByteBuffer bb = ByteBuffer.allocate(4 + 32 + 4 + BodyTargetSupport.externalSize(toLogin)).order(ByteOrder.BIG_ENDIAN);
bb.putInt(prevConnectionBlockNumber).put(prevConnectionBlockHash32).putInt(connectionSequence);
BodyTargetSupport.writeExternal(bb, toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "CONNECTION");
@Override
public byte[] toBytes() {
byte[] bchBytes = toBlockchainName.getBytes(StandardCharsets.UTF_8);
if (bchBytes.length == 0 || bchBytes.length > 255)
throw new IllegalArgumentException("toBlockchainName utf8 len must be 1..255");
if (toBlockHash32 == null || toBlockHash32.length != 32)
throw new IllegalArgumentException("toBlockHash32 != 32");
int cap = 4 + (4 + 32 + 4)
+ 1 + bchBytes.length
+ 4 + 32;
ByteBuffer bb = ByteBuffer.allocate(cap).order(ByteOrder.BIG_ENDIAN);
bb.putInt(lineCode);
bb.putInt(prevLineNumber);
bb.put(prevLineHash32 == null ? new byte[32] : Arrays.copyOf(prevLineHash32, 32));
bb.putInt(thisLineNumber);
bb.put((byte) bchBytes.length);
bb.put(bchBytes);
bb.putInt(toBlockGlobalNumber);
bb.put(toBlockHash32);
return bb.array();
}
@Override public int lineCode() { return 0; }
@Override public int prevLineBlockGlobalNumber() { return prevConnectionBlockNumber; }
@Override public byte[] prevLineBlockHash32() { return Arrays.copyOf(prevConnectionBlockHash32, 32); }
@Override public int lineSeq() { return connectionSequence; }
@Override public String toLogin() { return toLogin; }
@Override public Integer toForkNumber() { return toForkNumber; }
@Override public Integer toBlockGlobalNumber() { return toBlockGlobalNumber; }
@Override public byte[] toBlockHashBytes() { return Arrays.copyOf(toBlockHash32, 32); }
private static boolean isValidSubType(short st) {
int v = st & 0xFFFF;
return v == (MsgSubType.CONNECTION_CLOSE_FRIEND & 0xFFFF) || v == (MsgSubType.CONNECTION_UNCLOSE_FRIEND & 0xFFFF)
|| v == (MsgSubType.CONNECTION_FRIEND & 0xFFFF) || v == (MsgSubType.CONNECTION_UNFRIEND & 0xFFFF)
|| v == (MsgSubType.CONNECTION_CONTACT & 0xFFFF) || v == (MsgSubType.CONNECTION_UNCONTACT & 0xFFFF)
|| v == (MsgSubType.CONNECTION_FOLLOW & 0xFFFF) || v == (MsgSubType.CONNECTION_UNFOLLOW & 0xFFFF)
|| v == (MsgSubType.CONNECTION_SPOUSE & 0xFFFF) || v == (MsgSubType.CONNECTION_UNSPOUSE & 0xFFFF)
|| v == (MsgSubType.CONNECTION_PARENT & 0xFFFF) || v == (MsgSubType.CONNECTION_UNPARENT & 0xFFFF)
|| v == (MsgSubType.CONNECTION_CHILD & 0xFFFF) || v == (MsgSubType.CONNECTION_UNCHILD & 0xFFFF)
|| v == (MsgSubType.CONNECTION_SIBLING & 0xFFFF) || v == (MsgSubType.CONNECTION_UNSIBLING & 0xFFFF)
|| v == (MsgSubType.CONNECTION_KNOWN_PERSON & 0xFFFF) || v == (MsgSubType.CONNECTION_UNKNOWN_PERSON & 0xFFFF)
|| v == (MsgSubType.CONNECTION_SHINE_CONFIRMED & 0xFFFF) || v == (MsgSubType.CONNECTION_SHINE_UNCONFIRMED & 0xFFFF)
|| v == (MsgSubType.CONNECTION_SHINE_SEEN & 0xFFFF) || v == (MsgSubType.CONNECTION_SHINE_UNSEEN & 0xFFFF)
|| v == (MsgSubType.CONNECTION_OFFICIAL_ACCOUNT_CONFIRMED & 0xFFFF) || v == (MsgSubType.CONNECTION_OFFICIAL_ACCOUNT_UNCONFIRMED & 0xFFFF);
private static boolean isAllZero32(byte[] b) {
if (b == null || b.length != 32) return true;
for (int i = 0; i < 32; i++) if (b[i] != 0) return false;
return true;
}
/* ====================== BodyHasLine ====================== */
@Override public int lineCode() { return lineCode; }
@Override public int prevLineBlockGlobalNumber() { return prevLineNumber; }
@Override public byte[] prevLineBlockHash32() { return prevLineHash32 == null ? null : Arrays.copyOf(prevLineHash32, 32); }
@Override public int lineSeq() { return thisLineNumber; }
/* ====================== BodyHasTarget ===================== */
@Override public String toBchName() { return toBlockchainName; }
@Override public Integer toBlockGlobalNumber() { return toBlockGlobalNumber; }
@Override public byte[] toBlockHashBytes() { return toBlockHash32; }
}
@@ -37,8 +37,6 @@ public final class CreateChannelBody implements BodyRecord, BodyHasLine {
public static final short CHANNEL_TYPE_VERSION_DEFAULT = 1;
private static final byte[] ZERO32 = new byte[32];
// Минимум для создания нового канала; исторические блоки 1–3 символа читаются.
public static final int MIN_NAME_LENGTH_FOR_CREATE = 4;
private static final int MAX_NAME_LENGTH = 32;
public static final int MAX_DESCRIPTION_UTF8_LEN = 2048;
@@ -161,20 +159,6 @@ public final class CreateChannelBody implements BodyRecord, BodyHasLine {
return this;
}
/**
* Правило создания нового TECH_CREATE_CHANNEL (в отличие от чтения истории).
* check() намеренно принимает старые каналы с именами из 1–3 символов.
*/
public CreateChannelBody checkForCreate() {
check();
String normalizedName = normalizeDisplayName(channelName);
int length = normalizedName.codePointCount(0, normalizedName.length());
if (length < MIN_NAME_LENGTH_FOR_CREATE) {
throw new IllegalArgumentException("channelName length must be 4..32");
}
return this;
}
private static String normalizeDisplayName(String value) {
if (value == null) return "";
return value.trim().replaceAll("\\s+", " ");
@@ -187,9 +171,6 @@ public final class CreateChannelBody implements BodyRecord, BodyHasLine {
@Override
public byte[] toBytes() {
// Новые блоки кодируются только с именем от 4 символов.
// Исторические блоки при чтении разбираются без повторного кодирования.
checkForCreate();
byte[] nameUtf8 = normalizeDisplayName(channelName).getBytes(StandardCharsets.UTF_8);
if (nameUtf8.length == 0 || nameUtf8.length > 255) {
throw new IllegalArgumentException("channelName utf8 len must be 1..255");
@@ -1,235 +0,0 @@
package blockchain.body;
import blockchain.MsgSubType;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Objects;
/**
* TECH_FORK body (type=0, subType=2, version=1).
*
* TECH_FORK является обычным шагом общей TECH-линии. Поэтому body начинается
* тем же line-prefix, что и TECH_CREATE_CHANNEL.
*
* body bytes (BigEndian):
* [4] lineCode (=0 для TECH-линии)
* [4] prevLineNumber
* [32] prevLineHash32
* [4] thisLineNumber
*
* [32] parentBlockchainKey
* [4] forkPointBlockNumber
* [32] forkPointBlockHash32
* [8] forkPointTimestampMs
* [4] parentTipBlockNumber
* [32] parentTipBlockHash32
* [8] parentTipTimestampMs
* [4] discardedBlocksCount
* [1] reasonCode
* [2] commentUtf8Length
* [N] comment UTF-8 (0..1024 bytes)
*/
public final class ForkBody implements BodyRecord, BodyHasLine {
public static final short TYPE = 0;
public static final short VER = 1;
public static final short SUBTYPE = MsgSubType.TECH_FORK;
public static final int KEY = ((TYPE & 0xFFFF) << 16) | (VER & 0xFFFF);
public static final int REASON_ROUTINE_ROTATION = 1;
public static final int REASON_POSSIBLE_COMPROMISE = 2;
public static final int REASON_CONFIRMED_COMPROMISE_ROLLBACK = 3;
public static final int REASON_RECOVERY = 4;
public static final int MAX_COMMENT_UTF8_LEN = 1024;
private static final int LINE_PREFIX_LEN = 4 + 4 + 32 + 4;
private static final int FIXED_PAYLOAD_LEN = 32 + 4 + 32 + 8 + 4 + 32 + 8 + 4 + 1 + 2;
private static final int FIXED_LEN = LINE_PREFIX_LEN + FIXED_PAYLOAD_LEN;
public final short subType;
public final short version;
public final int lineCode;
public final int prevLineNumber;
public final byte[] prevLineHash32;
public final int thisLineNumber;
public final byte[] parentBlockchainKey32;
public final int forkPointBlockNumber;
public final byte[] forkPointBlockHash32;
public final long forkPointTimestampMs;
public final int parentTipBlockNumber;
public final byte[] parentTipBlockHash32;
public final long parentTipTimestampMs;
public final int discardedBlocksCount;
public final int reasonCode;
public final String comment;
public ForkBody(short subType, short version, byte[] bodyBytes) {
Objects.requireNonNull(bodyBytes, "bodyBytes == null");
this.subType = subType;
this.version = version;
if ((subType & 0xFFFF) != (SUBTYPE & 0xFFFF)) {
throw new IllegalArgumentException("ForkBody subType must be TECH_FORK(2)");
}
if ((version & 0xFFFF) != (VER & 0xFFFF)) {
throw new IllegalArgumentException("ForkBody version must be 1");
}
if (bodyBytes.length < FIXED_LEN) {
throw new IllegalArgumentException("ForkBody too short");
}
ByteBuffer bb = ByteBuffer.wrap(bodyBytes).order(ByteOrder.BIG_ENDIAN);
this.lineCode = bb.getInt();
this.prevLineNumber = bb.getInt();
this.prevLineHash32 = new byte[32];
bb.get(this.prevLineHash32);
this.thisLineNumber = bb.getInt();
this.parentBlockchainKey32 = new byte[32];
bb.get(this.parentBlockchainKey32);
this.forkPointBlockNumber = bb.getInt();
this.forkPointBlockHash32 = new byte[32];
bb.get(this.forkPointBlockHash32);
this.forkPointTimestampMs = bb.getLong();
this.parentTipBlockNumber = bb.getInt();
this.parentTipBlockHash32 = new byte[32];
bb.get(this.parentTipBlockHash32);
this.parentTipTimestampMs = bb.getLong();
this.discardedBlocksCount = bb.getInt();
this.reasonCode = Byte.toUnsignedInt(bb.get());
int commentLen = Short.toUnsignedInt(bb.getShort());
if (commentLen > MAX_COMMENT_UTF8_LEN) {
throw new IllegalArgumentException("ForkBody comment utf8 len must be <=1024");
}
if (bb.remaining() != commentLen) {
throw new IllegalArgumentException("ForkBody tail mismatch: remaining=" + bb.remaining() + " commentLen=" + commentLen);
}
byte[] commentBytes = new byte[commentLen];
bb.get(commentBytes);
this.comment = new String(commentBytes, StandardCharsets.UTF_8);
}
public ForkBody(int lineCode,
int prevLineNumber,
byte[] prevLineHash32,
int thisLineNumber,
byte[] parentBlockchainKey32,
int forkPointBlockNumber,
byte[] forkPointBlockHash32,
long forkPointTimestampMs,
int parentTipBlockNumber,
byte[] parentTipBlockHash32,
long parentTipTimestampMs,
int discardedBlocksCount,
int reasonCode,
String comment) {
this.subType = SUBTYPE;
this.version = VER;
this.lineCode = lineCode;
this.prevLineNumber = prevLineNumber;
this.prevLineHash32 = copy32(prevLineHash32, "prevLineHash32");
this.thisLineNumber = thisLineNumber;
this.parentBlockchainKey32 = copy32(parentBlockchainKey32, "parentBlockchainKey32");
this.forkPointBlockNumber = forkPointBlockNumber;
this.forkPointBlockHash32 = copy32(forkPointBlockHash32, "forkPointBlockHash32");
this.forkPointTimestampMs = forkPointTimestampMs;
this.parentTipBlockNumber = parentTipBlockNumber;
this.parentTipBlockHash32 = copy32(parentTipBlockHash32, "parentTipBlockHash32");
this.parentTipTimestampMs = parentTipTimestampMs;
this.discardedBlocksCount = discardedBlocksCount;
this.reasonCode = reasonCode;
this.comment = normalizeComment(comment);
}
@Override
public ForkBody check() {
if ((subType & 0xFFFF) != (SUBTYPE & 0xFFFF)) {
throw new IllegalArgumentException("ForkBody subType must be TECH_FORK(2)");
}
if ((version & 0xFFFF) != (VER & 0xFFFF)) {
throw new IllegalArgumentException("ForkBody version must be 1");
}
if (lineCode != 0) throw new IllegalArgumentException("ForkBody lineCode must be 0");
if (prevLineNumber < 0) throw new IllegalArgumentException("prevLineNumber must be >=0");
require32(prevLineHash32, "prevLineHash32");
if (thisLineNumber <= 0) throw new IllegalArgumentException("thisLineNumber must be >=1");
require32(parentBlockchainKey32, "parentBlockchainKey32");
require32(forkPointBlockHash32, "forkPointBlockHash32");
require32(parentTipBlockHash32, "parentTipBlockHash32");
if (forkPointBlockNumber < 0) throw new IllegalArgumentException("forkPointBlockNumber < 0");
if (parentTipBlockNumber < forkPointBlockNumber) {
throw new IllegalArgumentException("parentTipBlockNumber < forkPointBlockNumber");
}
if (forkPointTimestampMs < 0) throw new IllegalArgumentException("forkPointTimestampMs < 0");
if (parentTipTimestampMs < 0) throw new IllegalArgumentException("parentTipTimestampMs < 0");
int expectedDiscarded = parentTipBlockNumber - forkPointBlockNumber;
if (discardedBlocksCount != expectedDiscarded) {
throw new IllegalArgumentException("discardedBlocksCount must equal parentTipBlockNumber - forkPointBlockNumber");
}
if (!isReasonSupported(reasonCode)) {
throw new IllegalArgumentException("Unsupported fork reasonCode=" + reasonCode);
}
byte[] commentUtf8 = normalizeComment(comment).getBytes(StandardCharsets.UTF_8);
if (commentUtf8.length > MAX_COMMENT_UTF8_LEN) {
throw new IllegalArgumentException("ForkBody comment utf8 len must be <=1024");
}
return this;
}
@Override
public byte[] toBytes() {
check();
byte[] commentUtf8 = normalizeComment(comment).getBytes(StandardCharsets.UTF_8);
ByteBuffer bb = ByteBuffer.allocate(FIXED_LEN + commentUtf8.length).order(ByteOrder.BIG_ENDIAN);
bb.putInt(lineCode);
bb.putInt(prevLineNumber);
bb.put(prevLineHash32);
bb.putInt(thisLineNumber);
bb.put(parentBlockchainKey32);
bb.putInt(forkPointBlockNumber);
bb.put(forkPointBlockHash32);
bb.putLong(forkPointTimestampMs);
bb.putInt(parentTipBlockNumber);
bb.put(parentTipBlockHash32);
bb.putLong(parentTipTimestampMs);
bb.putInt(discardedBlocksCount);
bb.put((byte) reasonCode);
bb.putShort((short) commentUtf8.length);
bb.put(commentUtf8);
return bb.array();
}
@Override public int lineCode() { return lineCode; }
@Override public int prevLineBlockGlobalNumber() { return prevLineNumber; }
@Override public byte[] prevLineBlockHash32() { return Arrays.copyOf(prevLineHash32, 32); }
@Override public int lineSeq() { return thisLineNumber; }
public static boolean isReasonSupported(int code) {
return code == REASON_ROUTINE_ROTATION
|| code == REASON_POSSIBLE_COMPROMISE
|| code == REASON_CONFIRMED_COMPROMISE_ROLLBACK
|| code == REASON_RECOVERY;
}
private static byte[] copy32(byte[] value, String name) {
require32(value, name);
return Arrays.copyOf(value, 32);
}
private static void require32(byte[] value, String name) {
if (value == null || value.length != 32) {
throw new IllegalArgumentException(name + " must be 32 bytes");
}
}
private static String normalizeComment(String value) {
if (value == null) return "";
return value.trim().replace("\r\n", "\n").replace('\r', '\n');
}
}
@@ -5,113 +5,123 @@ import utils.config.ShineSignatureConstants;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Objects;
/**
* HeaderBody — type=0, subType=0, version=1.
* HeaderBody — type=0, version=1.
*
* В новом формате type/subType/version живут в HEADER блока,
* поэтому bodyBytes для HeaderBody содержат только payload:
*
* bodyBytes (BigEndian):
* [TAG_LEN] tag ASCII
* [1] loginLength (uint8)
* [N] login UTF-8
* [32] initialBlockchainKey32
*
* initialBlockchainKey32 is the public blockchain-signing key that created fork #1.
* It is historical identity metadata and MUST remain byte-for-byte unchanged when a
* preserved prefix (including block #0) is republished into later forks.
* [TAG_LEN] tag ASCII "SHiNE"
* [1] loginLength=N (uint8)
* [N] login UTF-8
*/
public final class HeaderBody implements BodyRecord {
public static final short TYPE = 0;
public static final short VER = 1;
public static final short VER = 1;
public static final int KEY = ((TYPE & 0xFFFF) << 16) | (VER & 0xFFFF);
/** Для header subType всегда 0 (служебная совместимость). */
public static final short SUBTYPE_COMPAT = 0;
/** TAG формата (ASCII). */
public static final String TAG = ShineSignatureConstants.BLOCKCHAIN_HEADER_TAG;
private static final byte[] TAG_ASCII = TAG.getBytes(StandardCharsets.US_ASCII);
private static final int TAG_LEN = TAG_ASCII.length;
public final short subType;
public final short version;
public final String tag;
public final short subType; // всегда 0 (из заголовка блока)
public final short version; // из заголовка блока
public final String tag; // "SHiNE"
public final String login;
public final byte[] initialBlockchainKey32;
/** Десериализация из payload bodyBytes (без type/subType/version). */
public HeaderBody(short subType, short version, byte[] bodyBytes) {
Objects.requireNonNull(bodyBytes, "bodyBytes == null");
this.subType = subType;
this.version = version;
if ((subType & 0xFFFF) != 0) throw new IllegalArgumentException("HeaderBody subType must be 0");
if ((version & 0xFFFF) != (VER & 0xFFFF)) throw new IllegalArgumentException("HeaderBody version must be 1");
if (bodyBytes.length < TAG_LEN + 1 + 1 + 32) throw new IllegalArgumentException("HeaderBody too short");
if ((this.subType & 0xFFFF) != (SUBTYPE_COMPAT & 0xFFFF)) {
throw new IllegalArgumentException("HeaderBody subType must be 0, got=" + (this.subType & 0xFFFF));
}
if ((this.version & 0xFFFF) != (VER & 0xFFFF)) {
throw new IllegalArgumentException("HeaderBody version must be 1, got=" + (this.version & 0xFFFF));
}
// минимум: tag[TAG_LEN] + loginLen[1]
if (bodyBytes.length < TAG_LEN + 1) throw new IllegalArgumentException("HeaderBody too short");
ByteBuffer bb = ByteBuffer.wrap(bodyBytes).order(ByteOrder.BIG_ENDIAN);
byte[] tagBytes = new byte[TAG_LEN];
bb.get(tagBytes);
String parsedTag = new String(tagBytes, StandardCharsets.US_ASCII);
if (!TAG.equals(parsedTag)) throw new IllegalArgumentException("Bad tag: " + parsedTag);
this.tag = parsedTag;
String t = new String(tagBytes, StandardCharsets.US_ASCII);
if (!TAG.equals(t)) throw new IllegalArgumentException("Bad tag: " + t);
this.tag = t;
int loginLen = Byte.toUnsignedInt(bb.get());
if (loginLen <= 0 || bb.remaining() != loginLen + 32) throw new IllegalArgumentException("Bad HeaderBody login/key length");
if (loginLen <= 0 || bb.remaining() < loginLen)
throw new IllegalArgumentException("Bad login length");
byte[] loginBytes = new byte[loginLen];
bb.get(loginBytes);
this.login = BodyTargetSupport.decodeStrictUtf8(loginBytes, "HeaderBody login");
this.initialBlockchainKey32 = new byte[32];
bb.get(this.initialBlockchainKey32);
requireNonZeroKey(this.initialBlockchainKey32);
if (bb.hasRemaining()) throw new IllegalArgumentException("Unexpected HeaderBody tail");
this.login = new String(loginBytes, StandardCharsets.UTF_8);
if (bb.remaining() != 0) throw new IllegalArgumentException("Unexpected tail bytes, remaining=" + bb.remaining());
}
public HeaderBody(String login, byte[] initialBlockchainKey32) {
/** Создание “вручную”. */
public HeaderBody(String login) {
Objects.requireNonNull(login, "login == null");
Objects.requireNonNull(initialBlockchainKey32, "initialBlockchainKey32 == null");
this.subType = SUBTYPE_COMPAT;
this.version = VER;
this.tag = TAG;
this.login = login;
this.initialBlockchainKey32 = Arrays.copyOf(initialBlockchainKey32, initialBlockchainKey32.length);
check();
}
@Override
public HeaderBody check() {
if ((subType & 0xFFFF) != 0) throw new IllegalArgumentException("HeaderBody subType must be 0");
if (login == null || login.isBlank()) throw new IllegalArgumentException("Login is blank");
byte[] loginUtf8 = login.getBytes(StandardCharsets.UTF_8);
// В HEADER хранится неизменяемое написание зарегистрированного login@namespace.
// Namespace остаётся lowercase, регистр локальной части сохраняется байт-в-байт.
boolean legacyLogin = login.matches("^[A-Za-z0-9_]+$");
boolean namespacedLogin = loginUtf8.length <= 30 && login.matches("^[A-Za-z0-9_]+@[a-z0-9_]+$");
if (!legacyLogin && !namespacedLogin) {
throw new IllegalArgumentException("Login must be legacy [A-Za-z0-9_]+ or registered-case login@namespace (max 30 bytes)");
}
if (loginUtf8.length == 0 || loginUtf8.length > 255) throw new IllegalArgumentException("Login utf8 len must be 1..255");
requireNonZeroKey(initialBlockchainKey32);
if ((subType & 0xFFFF) != (SUBTYPE_COMPAT & 0xFFFF))
throw new IllegalArgumentException("HeaderBody subType must be 0");
if (login == null || login.isBlank())
throw new IllegalArgumentException("Login is blank");
if (!login.matches("^[A-Za-z0-9_]+$"))
throw new IllegalArgumentException("Login must match ^[A-Za-z0-9_]+$");
return this;
}
@Override
public byte[] toBytes() {
check();
byte[] loginUtf8 = login.getBytes(StandardCharsets.UTF_8);
ByteBuffer bb = ByteBuffer.allocate(TAG_LEN + 1 + loginUtf8.length + 32).order(ByteOrder.BIG_ENDIAN);
if (loginUtf8.length == 0 || loginUtf8.length > 255)
throw new IllegalArgumentException("Login utf8 len must be 1..255");
int cap = TAG_LEN + 1 + loginUtf8.length;
ByteBuffer bb = ByteBuffer.allocate(cap).order(ByteOrder.BIG_ENDIAN);
bb.put(TAG_ASCII);
bb.put((byte) loginUtf8.length);
bb.put(loginUtf8);
bb.put(initialBlockchainKey32);
return bb.array();
}
private static void requireNonZeroKey(byte[] key) {
if (key == null || key.length != 32) throw new IllegalArgumentException("initialBlockchainKey32 must be 32 bytes");
boolean any = false;
for (byte b : key) any |= b != 0;
if (!any) throw new IllegalArgumentException("initialBlockchainKey32 must not be zero");
return bb.array();
}
@Override
public String toString() {
return "HeaderBody{login='" + login + "', initialBlockchainKey32=<32 bytes>}";
return """
HeaderBody {
тип записи : HEADER (type=0, ver=1) [в заголовке блока]
subType : 0 (compat)
тег формата : "%s"
login владельца : "%s"
}
""".formatted(tag, login);
}
}
}
@@ -4,68 +4,130 @@ import blockchain.MsgSubType;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Objects;
/** REACTION LIKE/UNLIKE. External target = login + forkNumber + blockNumber + hash32. */
/**
* ReactionBody — type=2, version=1 (в заголовке блока).
*
* subType (в заголовке блока):
* 1 = LIKE
* 2 = UNLIKE
*
* bodyBytes (BigEndian), новый формат:
* [1] toBlockchainNameLen (uint8)
* [N] toBlockchainName UTF-8
* [4] toBlockGlobalNumber (int32)
* [32] toBlockHash32 (raw 32 bytes)
*
* ЛИНИИ НЕТ.
*/
public final class ReactionBody implements BodyRecord, BodyHasTarget {
public static final short TYPE = 2;
public static final short VER = 1;
public static final short VER = 1;
public static final int KEY = ((TYPE & 0xFFFF) << 16) | (VER & 0xFFFF);
public final short subType;
public final short version;
public final String toLogin;
public final int toForkNumber;
public final short subType; // из header
public final short version; // из header
public final String toBlockchainName;
public final int toBlockGlobalNumber;
public final byte[] toBlockHash32;
public ReactionBody(short subType, short version, byte[] bodyBytes) {
Objects.requireNonNull(bodyBytes, "bodyBytes == null");
this.subType = subType;
this.version = version;
if ((version & 0xFFFF) != (VER & 0xFFFF)) throw new IllegalArgumentException("ReactionBody version must be 1");
if (!isSupportedSubType(subType)) throw new IllegalArgumentException("Bad reaction subType: " + (subType & 0xFFFF));
if ((this.version & 0xFFFF) != (VER & 0xFFFF)) {
throw new IllegalArgumentException("ReactionBody version must be 1, got=" + (this.version & 0xFFFF));
}
if (!isSupportedSubType(this.subType)) {
throw new IllegalArgumentException("Bad reaction subType: " + (this.subType & 0xFFFF));
}
// минимум: nameLen[1]+name[1]+global[4]+hash[32]
if (bodyBytes.length < 1 + 1 + 4 + 32) throw new IllegalArgumentException("ReactionBody too short");
ByteBuffer bb = ByteBuffer.wrap(bodyBytes).order(ByteOrder.BIG_ENDIAN);
BodyTargetSupport.ExternalTarget t = BodyTargetSupport.readExternal(bb, "REACTION", 0);
this.toLogin = t.login();
this.toForkNumber = t.forkNumber();
this.toBlockGlobalNumber = t.blockNumber();
this.toBlockHash32 = t.blockHash32();
if (bb.hasRemaining()) throw new IllegalArgumentException("Unexpected REACTION tail");
int nameLen = Byte.toUnsignedInt(bb.get());
if (nameLen <= 0) throw new IllegalArgumentException("toBlockchainNameLen is 0");
if (bb.remaining() < nameLen + 4 + 32) throw new IllegalArgumentException("ReactionBody payload too short");
byte[] nameBytes = new byte[nameLen];
bb.get(nameBytes);
this.toBlockchainName = new String(nameBytes, StandardCharsets.UTF_8);
this.toBlockGlobalNumber = bb.getInt();
this.toBlockHash32 = new byte[32];
bb.get(this.toBlockHash32);
if (bb.remaining() != 0) throw new IllegalArgumentException("Unexpected tail bytes, remaining=" + bb.remaining());
}
public ReactionBody(short subType, String toLogin, int toForkNumber, int toBlockGlobalNumber, byte[] toBlockHash32) {
if (!isSupportedSubType(subType)) throw new IllegalArgumentException("Bad reaction subType");
BodyTargetSupport.validateExternal(toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "REACTION");
this.subType = subType;
public ReactionBody(String toBlockchainName, int toBlockGlobalNumber, byte[] toBlockHash32) {
Objects.requireNonNull(toBlockchainName, "toBlockchainName == null");
Objects.requireNonNull(toBlockHash32, "toBlockHash32 == null");
this.subType = MsgSubType.REACTION_LIKE;
this.version = VER;
this.toLogin = toLogin;
this.toForkNumber = toForkNumber;
if (toBlockchainName.isBlank()) throw new IllegalArgumentException("toBlockchainName is blank");
if (toBlockGlobalNumber < 0) throw new IllegalArgumentException("toBlockGlobalNumber < 0");
if (toBlockHash32.length != 32) throw new IllegalArgumentException("toBlockHash32 != 32");
this.toBlockchainName = toBlockchainName;
this.toBlockGlobalNumber = toBlockGlobalNumber;
this.toBlockHash32 = Arrays.copyOf(toBlockHash32, 32);
}
@Override public ReactionBody check() {
if (!isSupportedSubType(subType)) throw new IllegalArgumentException("Bad reaction subType");
BodyTargetSupport.validateExternal(toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "REACTION");
@Override
public ReactionBody check() {
if (!isSupportedSubType(subType))
throw new IllegalArgumentException("Bad reaction subType: " + (subType & 0xFFFF));
if (toBlockchainName == null || toBlockchainName.isBlank())
throw new IllegalArgumentException("toBlockchainName is blank");
if (toBlockGlobalNumber < 0)
throw new IllegalArgumentException("toBlockGlobalNumber < 0");
if (toBlockHash32 == null || toBlockHash32.length != 32)
throw new IllegalArgumentException("toBlockHash32 invalid");
return this;
}
@Override public byte[] toBytes() {
check();
ByteBuffer bb = ByteBuffer.allocate(BodyTargetSupport.externalSize(toLogin)).order(ByteOrder.BIG_ENDIAN);
BodyTargetSupport.writeExternal(bb, toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "REACTION");
@Override
public byte[] toBytes() {
byte[] nameBytes = toBlockchainName.getBytes(StandardCharsets.UTF_8);
if (nameBytes.length == 0 || nameBytes.length > 255)
throw new IllegalArgumentException("toBlockchainName utf8 len must be 1..255");
int cap = 1 + nameBytes.length + 4 + 32;
ByteBuffer bb = ByteBuffer.allocate(cap).order(ByteOrder.BIG_ENDIAN);
bb.put((byte) nameBytes.length);
bb.put(nameBytes);
bb.putInt(toBlockGlobalNumber);
bb.put(toBlockHash32);
return bb.array();
}
@Override public String toLogin() { return toLogin; }
@Override public Integer toForkNumber() { return toForkNumber; }
/* ====================== BodyHasTarget ====================== */
@Override public String toBchName() { return toBlockchainName; }
@Override public Integer toBlockGlobalNumber() { return toBlockGlobalNumber; }
@Override public byte[] toBlockHashBytes() { return Arrays.copyOf(toBlockHash32, 32); }
@Override public byte[] toBlockHashBytes() { return toBlockHash32; }
private static boolean isSupportedSubType(short subType) {
int st = subType & 0xFFFF;
return st == (MsgSubType.REACTION_LIKE & 0xFFFF) || st == (MsgSubType.REACTION_UNLIKE & 0xFFFF);
return st == (MsgSubType.REACTION_LIKE & 0xFFFF)
|| st == (MsgSubType.REACTION_UNLIKE & 0xFFFF);
}
}
@@ -10,78 +10,157 @@ import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Objects;
/** STATUS_ACTION. External target = login + forkNumber + blockNumber + hash32. */
/**
* StatusActionBody — type=5, ver=1.
*
* Все STATUS_ACTION имеют target на конкретный блок и опциональный текст-пояснение.
*
* Формат bodyBytes (BigEndian):
* [1] toBlockchainNameLen (uint8)
* [N] toBlockchainName UTF-8
* [4] toBlockGlobalNumber
* [32] toBlockHash32
* [2] textLenBytes (uint16)
* [M] text UTF-8
*/
public final class StatusActionBody implements BodyRecord, BodyHasTarget {
public static final short TYPE = 5;
public static final short VER = 1;
public static final int KEY = ((TYPE & 0xFFFF) << 16) | (VER & 0xFFFF);
public final short subType;
public final short version;
public final String toLogin;
public final int toForkNumber;
public final String toBlockchainName;
public final int toBlockGlobalNumber;
public final byte[] toBlockHash32;
public final String message;
public StatusActionBody(short subType, short version, byte[] bodyBytes) {
Objects.requireNonNull(bodyBytes, "bodyBytes == null");
this.subType = subType; this.version = version;
if ((version & 0xFFFF) != 1 || !isSupportedSubType(subType)) throw new IllegalArgumentException("Bad STATUS_ACTION header");
this.subType = subType;
this.version = version;
if ((version & 0xFFFF) != (VER & 0xFFFF)) {
throw new IllegalArgumentException("StatusActionBody version must be 1, got=" + (version & 0xFFFF));
}
if (!isSupportedSubType(subType)) {
throw new IllegalArgumentException("Unsupported STATUS_ACTION subType: " + (subType & 0xFFFF));
}
ByteBuffer bb = ByteBuffer.wrap(bodyBytes).order(ByteOrder.BIG_ENDIAN);
BodyTargetSupport.ExternalTarget t = BodyTargetSupport.readExternal(bb, "STATUS_ACTION", 2);
this.toLogin = t.login(); this.toForkNumber = t.forkNumber(); this.toBlockGlobalNumber = t.blockNumber(); this.toBlockHash32 = t.blockHash32();
this.message = readText(bb);
if (bb.hasRemaining()) throw new IllegalArgumentException("Unexpected STATUS_ACTION tail");
ensureMin(bb, 1 + 1 + 4 + 32 + 2, "STATUS_ACTION too short");
int nameLen = Byte.toUnsignedInt(bb.get());
if (nameLen <= 0) throw new IllegalArgumentException("STATUS_ACTION toBlockchainNameLen is 0");
ensureMin(bb, nameLen + 4 + 32 + 2, "STATUS_ACTION payload too short");
byte[] nameBytes = new byte[nameLen];
bb.get(nameBytes);
this.toBlockchainName = new String(nameBytes, StandardCharsets.UTF_8);
this.toBlockGlobalNumber = bb.getInt();
this.toBlockHash32 = new byte[32];
bb.get(this.toBlockHash32);
this.message = readStrictUtf8Len16AllowEmpty(bb, "StatusActionBody text");
ensureNoTail(bb, "StatusActionBody");
}
public StatusActionBody(short subType, String toLogin, int toForkNumber, int toBlockGlobalNumber, byte[] toBlockHash32, String message) {
public StatusActionBody(short subType, String toBlockchainName, int toBlockGlobalNumber, byte[] toBlockHash32, String message) {
Objects.requireNonNull(toBlockchainName, "toBlockchainName == null");
Objects.requireNonNull(toBlockHash32, "toBlockHash32 == null");
Objects.requireNonNull(message, "message == null");
if (!isSupportedSubType(subType)) throw new IllegalArgumentException("Unsupported STATUS_ACTION subType");
BodyTargetSupport.validateExternal(toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "STATUS_ACTION");
this.subType = subType; this.version = VER; this.toLogin = toLogin; this.toForkNumber = toForkNumber;
this.toBlockGlobalNumber = toBlockGlobalNumber; this.toBlockHash32 = Arrays.copyOf(toBlockHash32, 32); this.message = message;
if (toBlockchainName.isBlank()) throw new IllegalArgumentException("toBlockchainName is blank");
if (toBlockGlobalNumber < 0) throw new IllegalArgumentException("toBlockGlobalNumber < 0");
if (toBlockHash32.length != 32) throw new IllegalArgumentException("toBlockHash32 != 32");
this.subType = subType;
this.version = VER;
this.toBlockchainName = toBlockchainName;
this.toBlockGlobalNumber = toBlockGlobalNumber;
this.toBlockHash32 = Arrays.copyOf(toBlockHash32, 32);
this.message = message;
}
@Override public StatusActionBody check() {
if (!isSupportedSubType(subType)) throw new IllegalArgumentException("Bad STATUS_ACTION subType");
BodyTargetSupport.validateExternal(toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "STATUS_ACTION");
@Override
public StatusActionBody check() {
if (!isSupportedSubType(subType)) {
throw new IllegalArgumentException("Bad STATUS_ACTION subType: " + (subType & 0xFFFF));
}
if (toBlockchainName == null || toBlockchainName.isBlank()) {
throw new IllegalArgumentException("STATUS_ACTION toBlockchainName is blank");
}
if (toBlockGlobalNumber < 0) throw new IllegalArgumentException("toBlockGlobalNumber < 0");
if (toBlockHash32 == null || toBlockHash32.length != 32) {
throw new IllegalArgumentException("toBlockHash32 invalid");
}
if (message == null) throw new IllegalArgumentException("message is null");
if (message.getBytes(StandardCharsets.UTF_8).length > 65535) throw new IllegalArgumentException("Text too long");
return this;
}
@Override public byte[] toBytes() {
check();
byte[] text = message.getBytes(StandardCharsets.UTF_8);
ByteBuffer bb = ByteBuffer.allocate(BodyTargetSupport.externalSize(toLogin) + 2 + text.length).order(ByteOrder.BIG_ENDIAN);
BodyTargetSupport.writeExternal(bb, toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "STATUS_ACTION");
bb.putShort((short) text.length).put(text);
@Override
public byte[] toBytes() {
byte[] msgUtf8 = message.getBytes(StandardCharsets.UTF_8);
if (msgUtf8.length > 65535) throw new IllegalArgumentException("Text too long (>65535 bytes)");
byte[] nameUtf8 = toBlockchainName.getBytes(StandardCharsets.UTF_8);
if (nameUtf8.length == 0 || nameUtf8.length > 255) {
throw new IllegalArgumentException("STATUS_ACTION toBlockchainName utf8 len must be 1..255");
}
ByteBuffer bb = ByteBuffer.allocate(1 + nameUtf8.length + 4 + 32 + 2 + msgUtf8.length)
.order(ByteOrder.BIG_ENDIAN);
bb.put((byte) nameUtf8.length);
bb.put(nameUtf8);
bb.putInt(toBlockGlobalNumber);
bb.put(toBlockHash32);
bb.putShort((short) msgUtf8.length);
bb.put(msgUtf8);
return bb.array();
}
@Override public String toLogin() { return toLogin; }
@Override public Integer toForkNumber() { return toForkNumber; }
@Override public String toBchName() { return toBlockchainName; }
@Override public Integer toBlockGlobalNumber() { return toBlockGlobalNumber; }
@Override public byte[] toBlockHashBytes() { return Arrays.copyOf(toBlockHash32, 32); }
@Override public byte[] toBlockHashBytes() { return toBlockHash32; }
private static boolean isSupportedSubType(short subType) {
int st = subType & 0xFFFF;
return st == (MsgSubType.STATUS_DONE_ONCE & 0xFFFF) || st == (MsgSubType.STATUS_LEARNED & 0xFFFF)
|| st == (MsgSubType.STATUS_SERVICE_PASSED & 0xFFFF) || st == (MsgSubType.STATUS_CONFIRMED & 0xFFFF)
|| st == (MsgSubType.STATUS_INTERESTED & 0xFFFF) || st == (MsgSubType.STATUS_STARTED & 0xFFFF)
|| st == (MsgSubType.STATUS_IN_STUDY & 0xFFFF) || st == (MsgSubType.STATUS_ABANDONED & 0xFFFF)
return st == (MsgSubType.STATUS_DONE_ONCE & 0xFFFF)
|| st == (MsgSubType.STATUS_LEARNED & 0xFFFF)
|| st == (MsgSubType.STATUS_SERVICE_PASSED & 0xFFFF)
|| st == (MsgSubType.STATUS_CONFIRMED & 0xFFFF)
|| st == (MsgSubType.STATUS_INTERESTED & 0xFFFF)
|| st == (MsgSubType.STATUS_STARTED & 0xFFFF)
|| st == (MsgSubType.STATUS_IN_STUDY & 0xFFFF)
|| st == (MsgSubType.STATUS_ABANDONED & 0xFFFF)
|| st == (MsgSubType.STATUS_COMPLETED & 0xFFFF);
}
private static String readText(ByteBuffer bb) {
if (bb.remaining() < 2) throw new IllegalArgumentException("STATUS_ACTION text length missing");
private static String readStrictUtf8Len16AllowEmpty(ByteBuffer bb, String fieldName) {
int len = Short.toUnsignedInt(bb.getShort());
if (bb.remaining() < len) throw new IllegalArgumentException("STATUS_ACTION text payload too short");
if (len == 0) return "";
byte[] bytes = new byte[len]; bb.get(bytes);
var dec = StandardCharsets.UTF_8.newDecoder().onMalformedInput(CodingErrorAction.REPORT).onUnmappableCharacter(CodingErrorAction.REPORT);
try { return dec.decode(ByteBuffer.wrap(bytes)).toString(); }
catch (CharacterCodingException e) { throw new IllegalArgumentException("STATUS_ACTION text invalid UTF-8", e); }
if (bb.remaining() < len) throw new IllegalArgumentException(fieldName + " payload too short (len=" + len + ")");
byte[] bytes = new byte[len];
bb.get(bytes);
var decoder = StandardCharsets.UTF_8.newDecoder()
.onMalformedInput(CodingErrorAction.REPORT)
.onUnmappableCharacter(CodingErrorAction.REPORT);
try {
return decoder.decode(ByteBuffer.wrap(bytes)).toString();
} catch (CharacterCodingException e) {
throw new IllegalArgumentException(fieldName + " is not valid UTF-8", e);
}
}
private static void ensureMin(ByteBuffer bb, int need, String msg) {
if (bb.remaining() < need) throw new IllegalArgumentException(msg + " (need=" + need + ", remaining=" + bb.remaining() + ")");
}
private static void ensureNoTail(ByteBuffer bb, String ctx) {
if (bb.remaining() != 0) throw new IllegalArgumentException("Unexpected tail bytes for " + ctx + ", remaining=" + bb.remaining());
}
}
@@ -0,0 +1,544 @@
package blockchain.body;
import blockchain.MsgSubType;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.CodingErrorAction;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Objects;
/**
* TextBody — type=1, ver=1 (в заголовке блока).
*
* subType (в заголовке блока):
* 10 = POST
* 11 = EDIT_POST
* 20 = REPLY
* 21 = EDIT_REPLY
*
* =========================================================================
* КОНЦЕПЦИЯ ЛИНИЙ ДЛЯ ТЕКСТОВЫХ СООБЩЕНИЙ:
*
* POST и EDIT_POST принадлежат ЛИНИИ КАНАЛА и имеют hasLine.
* В новом формате добавлен lineCode:
* lineCode = 0 для канала "0"
* lineCode = blockNumber "заглавия линии/канала" (например CREATE_CHANNEL)
*
* REPLY и EDIT_REPLY НЕ имеют линии (нет hasLine в байтах).
*
* =========================================================================
* ФОРМАТЫ bodyBytes (BigEndian):
*
* 1) POST (subType=10):
* [4] lineCode
* [4] prevLineNumber
* [32] prevLineHash32
* [4] thisLineNumber
* [2] textLenBytes (uint16)
* [N] text UTF-8
*
* 2) EDIT_POST (subType=11):
* [4] lineCode
* [4] prevLineNumber
* [32] prevLineHash32
* [4] thisLineNumber
*
* hasTarget (на ОРИГИНАЛЬНЫЙ POST, toBchName НЕ хранить):
* [4] toBlockGlobalNumber
* [32] toBlockHash32
*
* [2] textLenBytes (uint16)
* [N] text UTF-8
*
* 3) REPLY (subType=20) — НЕ в линии:
* hasTarget:
* [1] toBlockchainNameLen (uint8)
* [N] toBlockchainName UTF-8
* [4] toBlockGlobalNumber
* [32] toBlockHash32
*
* [2] textLenBytes (uint16)
* [M] text UTF-8
*
* 4) EDIT_REPLY (subType=21) — НЕ в линии:
* hasTarget (на ОРИГИНАЛЬНЫЙ REPLY, toBchName НЕ хранить):
* [4] toBlockGlobalNumber
* [32] toBlockHash32
*
* [2] textLenBytes (uint16)
* [N] text UTF-8
*/
public final class TextBody implements BodyRecord, BodyHasTarget, BodyHasLine {
public static final short TYPE = 1;
public static final short VER = 1;
public static final int KEY = ((TYPE & 0xFFFF) << 16) | (VER & 0xFFFF);
public final short subType; // из header
public final short version; // из header
// ===== line fields (только для POST/EDIT_POST) =====
// Для REPLY/EDIT_REPLY эти поля НЕ сериализуются; значения держим как "пустые".
public final int lineCode; // только для line-message; иначе -1
public final int prevLineNumber;
public final byte[] prevLineHash32; // 32 or null
public final int thisLineNumber;
// ===== message text =====
public final String message;
// ===== target fields =====
// REPLY: toBlockchainName + globalNumber + hash32
// EDIT_POST / EDIT_REPLY: только globalNumber + hash32 (без toBlockchainName)
public final String toBlockchainName; // nullable
public final Integer toBlockGlobalNumber; // nullable
public final byte[] toBlockHash32; // nullable (но если target есть -> 32)
/* ===================================================================== */
/* ====================== Конструктор из байт ========================== */
/* ===================================================================== */
public TextBody(short subType, short version, byte[] bodyBytes) {
Objects.requireNonNull(bodyBytes, "bodyBytes == null");
this.subType = subType;
this.version = version;
if ((this.version & 0xFFFF) != (VER & 0xFFFF)) {
throw new IllegalArgumentException("TextBody version must be 1, got=" + (this.version & 0xFFFF));
}
if (!isValidSubType(this.subType)) {
throw new IllegalArgumentException("Bad Text subType: " + (this.subType & 0xFFFF));
}
ByteBuffer bb = ByteBuffer.wrap(bodyBytes).order(ByteOrder.BIG_ENDIAN);
int st = this.subType & 0xFFFF;
if (st == (MsgSubType.TEXT_POST & 0xFFFF)) {
// POST: hasLine(lineCode+line) + text
ensureMin(bb, (4 + 4 + 32 + 4) + 2, "POST too short");
this.lineCode = bb.getInt();
this.prevLineNumber = bb.getInt();
this.prevLineHash32 = new byte[32];
bb.get(this.prevLineHash32);
this.thisLineNumber = bb.getInt();
this.message = readStrictUtf8Len16(bb, "POST text");
this.toBlockchainName = null;
this.toBlockGlobalNumber = null;
this.toBlockHash32 = null;
ensureNoTail(bb, "POST");
} else if (st == (MsgSubType.TEXT_EDIT_POST & 0xFFFF)) {
// EDIT_POST: hasLine(lineCode+line) + target(no bch) + text
ensureMin(bb, (4 + 4 + 32 + 4) + (4 + 32) + 2, "EDIT_POST too short");
this.lineCode = bb.getInt();
this.prevLineNumber = bb.getInt();
this.prevLineHash32 = new byte[32];
bb.get(this.prevLineHash32);
this.thisLineNumber = bb.getInt();
int tgtNum = bb.getInt();
byte[] tgtHash = new byte[32];
bb.get(tgtHash);
this.toBlockchainName = null;
this.toBlockGlobalNumber = tgtNum;
this.toBlockHash32 = tgtHash;
this.message = readStrictUtf8Len16(bb, "EDIT_POST text");
ensureNoTail(bb, "EDIT_POST");
} else if (st == (MsgSubType.TEXT_REPLY & 0xFFFF)) {
// REPLY: target(with bch) + text (без line)
ensureMin(bb, 1 + 1 + 4 + 32 + 2, "REPLY too short");
int nameLen = Byte.toUnsignedInt(bb.get());
if (nameLen <= 0) throw new IllegalArgumentException("REPLY toBlockchainNameLen is 0");
ensureMin(bb, nameLen + 4 + 32 + 2, "REPLY payload too short");
byte[] nameBytes = new byte[nameLen];
bb.get(nameBytes);
this.toBlockchainName = new String(nameBytes, StandardCharsets.UTF_8);
this.toBlockGlobalNumber = bb.getInt();
this.toBlockHash32 = new byte[32];
bb.get(this.toBlockHash32);
this.message = readStrictUtf8Len16(bb, "REPLY text");
// line fields отсутствуют в байтах
this.lineCode = -1;
this.prevLineNumber = -1;
this.prevLineHash32 = null;
this.thisLineNumber = -1;
ensureNoTail(bb, "REPLY");
} else if (st == (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF)) {
// EDIT_REPLY: target(no bch) + text (без line)
ensureMin(bb, (4 + 32) + 2, "EDIT_REPLY too short");
int tgtNum = bb.getInt();
byte[] tgtHash = new byte[32];
bb.get(tgtHash);
this.toBlockchainName = null;
this.toBlockGlobalNumber = tgtNum;
this.toBlockHash32 = tgtHash;
this.message = readStrictUtf8Len16(bb, "EDIT_REPLY text");
// line fields отсутствуют в байтах
this.lineCode = -1;
this.prevLineNumber = -1;
this.prevLineHash32 = null;
this.thisLineNumber = -1;
ensureNoTail(bb, "EDIT_REPLY");
} else {
throw new IllegalArgumentException("Unsupported Text subType: " + st);
}
}
/* ===================================================================== */
/* ====================== Фабрики (удобно) ============================= */
/* ===================================================================== */
public static TextBody newPost(int lineCode, int prevLineNumber, byte[] prevLineHash32, int thisLineNumber, String message) {
return new TextBody(MsgSubType.TEXT_POST, lineCode, prevLineNumber, prevLineHash32, thisLineNumber,
message, null, null, null);
}
public static TextBody newEditPost(int lineCode, int prevLineNumber, byte[] prevLineHash32, int thisLineNumber,
int targetBlockNumber, byte[] targetHash32,
String message) {
return new TextBody(MsgSubType.TEXT_EDIT_POST, lineCode, prevLineNumber, prevLineHash32, thisLineNumber,
message, null, targetBlockNumber, targetHash32);
}
public static TextBody newReply(String toBlockchainName, int targetBlockNumber, byte[] targetHash32, String message) {
return new TextBody(MsgSubType.TEXT_REPLY, -1, -1, null, -1,
message, toBlockchainName, targetBlockNumber, targetHash32);
}
public static TextBody newEditReply(int targetBlockNumber, byte[] targetHash32, String message) {
return new TextBody(MsgSubType.TEXT_EDIT_REPLY, -1, -1, null, -1,
message, null, targetBlockNumber, targetHash32);
}
/**
* Универсальный конструктор “вручную”.
* Для REPLY/EDIT_REPLY line поля игнорируются при сериализации (их в формате нет).
*/
public TextBody(short subType,
int lineCode,
int prevLineNumber,
byte[] prevLineHash32,
int thisLineNumber,
String message,
String toBlockchainName,
Integer toBlockGlobalNumber,
byte[] toBlockHash32) {
Objects.requireNonNull(message, "message == null");
if (!isValidSubType(subType)) throw new IllegalArgumentException("Bad Text subType: " + (subType & 0xFFFF));
if (message.isBlank()) throw new IllegalArgumentException("message is blank");
this.subType = subType;
this.version = VER;
int st = subType & 0xFFFF;
// line применима только к POST/EDIT_POST
if (st == (MsgSubType.TEXT_POST & 0xFFFF) || st == (MsgSubType.TEXT_EDIT_POST & 0xFFFF)) {
if (lineCode < 0) throw new IllegalArgumentException("lineCode < 0 for line message");
this.lineCode = lineCode;
this.prevLineNumber = prevLineNumber;
this.prevLineHash32 = (prevLineHash32 == null ? new byte[32] : Arrays.copyOf(prevLineHash32, 32));
this.thisLineNumber = thisLineNumber;
} else {
this.lineCode = -1;
this.prevLineNumber = -1;
this.prevLineHash32 = null;
this.thisLineNumber = -1;
}
this.message = message;
// target правила
if (st == (MsgSubType.TEXT_POST & 0xFFFF)) {
this.toBlockchainName = null;
this.toBlockGlobalNumber = null;
this.toBlockHash32 = null;
} else if (st == (MsgSubType.TEXT_EDIT_POST & 0xFFFF)) {
Objects.requireNonNull(toBlockGlobalNumber, "toBlockGlobalNumber == null");
Objects.requireNonNull(toBlockHash32, "toBlockHash32 == null");
if (toBlockGlobalNumber < 0) throw new IllegalArgumentException("toBlockGlobalNumber < 0");
if (toBlockHash32.length != 32) throw new IllegalArgumentException("toBlockHash32 != 32");
this.toBlockchainName = null; // по ТЗ: не хранить
this.toBlockGlobalNumber = toBlockGlobalNumber;
this.toBlockHash32 = Arrays.copyOf(toBlockHash32, 32);
} else if (st == (MsgSubType.TEXT_REPLY & 0xFFFF)) {
Objects.requireNonNull(toBlockchainName, "toBlockchainName == null");
Objects.requireNonNull(toBlockGlobalNumber, "toBlockGlobalNumber == null");
Objects.requireNonNull(toBlockHash32, "toBlockHash32 == null");
if (toBlockchainName.isBlank()) throw new IllegalArgumentException("toBlockchainName is blank");
if (toBlockGlobalNumber < 0) throw new IllegalArgumentException("toBlockGlobalNumber < 0");
if (toBlockHash32.length != 32) throw new IllegalArgumentException("toBlockHash32 != 32");
this.toBlockchainName = toBlockchainName;
this.toBlockGlobalNumber = toBlockGlobalNumber;
this.toBlockHash32 = Arrays.copyOf(toBlockHash32, 32);
} else if (st == (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF)) {
Objects.requireNonNull(toBlockGlobalNumber, "toBlockGlobalNumber == null");
Objects.requireNonNull(toBlockHash32, "toBlockHash32 == null");
if (toBlockGlobalNumber < 0) throw new IllegalArgumentException("toBlockGlobalNumber < 0");
if (toBlockHash32.length != 32) throw new IllegalArgumentException("toBlockHash32 != 32");
this.toBlockchainName = null; // по ТЗ: не хранить
this.toBlockGlobalNumber = toBlockGlobalNumber;
this.toBlockHash32 = Arrays.copyOf(toBlockHash32, 32);
} else {
this.toBlockchainName = null;
this.toBlockGlobalNumber = null;
this.toBlockHash32 = null;
}
}
private static boolean isValidSubType(short st) {
int v = st & 0xFFFF;
return v == (MsgSubType.TEXT_POST & 0xFFFF)
|| v == (MsgSubType.TEXT_EDIT_POST & 0xFFFF)
|| v == (MsgSubType.TEXT_REPLY & 0xFFFF)
|| v == (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF);
}
@Override
public TextBody check() {
if (!isValidSubType(subType))
throw new IllegalArgumentException("Bad Text subType: " + (subType & 0xFFFF));
if (message == null || message.isBlank())
throw new IllegalArgumentException("Text message is blank");
int st = subType & 0xFFFF;
// локальные проверки line (БД не трогаем)
if (st == (MsgSubType.TEXT_POST & 0xFFFF) || st == (MsgSubType.TEXT_EDIT_POST & 0xFFFF)) {
if (lineCode < 0) throw new IllegalArgumentException("lineCode < 0 for line message");
if (prevLineHash32 == null || prevLineHash32.length != 32)
throw new IllegalArgumentException("prevLineHash32 invalid");
} else {
// reply/edit_reply: line отсутствует
if (prevLineHash32 != null)
throw new IllegalArgumentException("REPLY/EDIT_REPLY must not contain line hash");
}
// target rules
if (st == (MsgSubType.TEXT_POST & 0xFFFF)) {
if (toBlockchainName != null || toBlockGlobalNumber != null || toBlockHash32 != null)
throw new IllegalArgumentException("POST must not contain target fields");
} else if (st == (MsgSubType.TEXT_EDIT_POST & 0xFFFF)) {
if (toBlockchainName != null)
throw new IllegalArgumentException("EDIT_POST must not contain toBlockchainName in target");
if (toBlockGlobalNumber == null || toBlockGlobalNumber < 0)
throw new IllegalArgumentException("EDIT_POST toBlockGlobalNumber invalid");
if (toBlockHash32 == null || toBlockHash32.length != 32)
throw new IllegalArgumentException("EDIT_POST toBlockHash32 invalid");
} else if (st == (MsgSubType.TEXT_REPLY & 0xFFFF)) {
if (toBlockchainName == null || toBlockchainName.isBlank())
throw new IllegalArgumentException("REPLY toBlockchainName is blank");
if (toBlockGlobalNumber == null || toBlockGlobalNumber < 0)
throw new IllegalArgumentException("REPLY toBlockGlobalNumber invalid");
if (toBlockHash32 == null || toBlockHash32.length != 32)
throw new IllegalArgumentException("REPLY toBlockHash32 invalid");
} else if (st == (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF)) {
if (toBlockchainName != null)
throw new IllegalArgumentException("EDIT_REPLY must not contain toBlockchainName in target");
if (toBlockGlobalNumber == null || toBlockGlobalNumber < 0)
throw new IllegalArgumentException("EDIT_REPLY toBlockGlobalNumber invalid");
if (toBlockHash32 == null || toBlockHash32.length != 32)
throw new IllegalArgumentException("EDIT_REPLY toBlockHash32 invalid");
}
return this;
}
@Override
public byte[] toBytes() {
byte[] msgUtf8 = message.getBytes(StandardCharsets.UTF_8);
if (msgUtf8.length == 0) throw new IllegalArgumentException("Text payload is empty");
if (msgUtf8.length > 65535) throw new IllegalArgumentException("Text too long (>65535 bytes)");
int st = subType & 0xFFFF;
if (st == (MsgSubType.TEXT_POST & 0xFFFF)) {
// hasLine(lineCode+line) + text
int cap = (4 + 4 + 32 + 4) + 2 + msgUtf8.length;
ByteBuffer bb = ByteBuffer.allocate(cap).order(ByteOrder.BIG_ENDIAN);
bb.putInt(lineCode);
bb.putInt(prevLineNumber);
bb.put(prevLineHash32 == null ? new byte[32] : Arrays.copyOf(prevLineHash32, 32));
bb.putInt(thisLineNumber);
bb.putShort((short) msgUtf8.length);
bb.put(msgUtf8);
return bb.array();
} else if (st == (MsgSubType.TEXT_EDIT_POST & 0xFFFF)) {
// hasLine(lineCode+line) + target(no bch) + text
if (toBlockGlobalNumber == null) throw new IllegalArgumentException("EDIT_POST missing toBlockGlobalNumber");
if (toBlockHash32 == null || toBlockHash32.length != 32) throw new IllegalArgumentException("EDIT_POST toBlockHash32 != 32");
int cap = (4 + 4 + 32 + 4) + (4 + 32) + 2 + msgUtf8.length;
ByteBuffer bb = ByteBuffer.allocate(cap).order(ByteOrder.BIG_ENDIAN);
bb.putInt(lineCode);
bb.putInt(prevLineNumber);
bb.put(prevLineHash32 == null ? new byte[32] : Arrays.copyOf(prevLineHash32, 32));
bb.putInt(thisLineNumber);
bb.putInt(toBlockGlobalNumber);
bb.put(toBlockHash32);
bb.putShort((short) msgUtf8.length);
bb.put(msgUtf8);
return bb.array();
} else if (st == (MsgSubType.TEXT_REPLY & 0xFFFF)) {
// target(with bch) + text
if (toBlockchainName == null) throw new IllegalArgumentException("REPLY missing toBlockchainName");
if (toBlockGlobalNumber == null) throw new IllegalArgumentException("REPLY missing toBlockGlobalNumber");
if (toBlockHash32 == null || toBlockHash32.length != 32) throw new IllegalArgumentException("REPLY toBlockHash32 != 32");
byte[] nameUtf8 = toBlockchainName.getBytes(StandardCharsets.UTF_8);
if (nameUtf8.length == 0 || nameUtf8.length > 255)
throw new IllegalArgumentException("REPLY toBlockchainName utf8 len must be 1..255");
int cap = 1 + nameUtf8.length + 4 + 32
+ 2 + msgUtf8.length;
ByteBuffer bb = ByteBuffer.allocate(cap).order(ByteOrder.BIG_ENDIAN);
bb.put((byte) nameUtf8.length);
bb.put(nameUtf8);
bb.putInt(toBlockGlobalNumber);
bb.put(toBlockHash32);
bb.putShort((short) msgUtf8.length);
bb.put(msgUtf8);
return bb.array();
} else if (st == (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF)) {
// target(no bch) + text
if (toBlockGlobalNumber == null) throw new IllegalArgumentException("EDIT_REPLY missing toBlockGlobalNumber");
if (toBlockHash32 == null || toBlockHash32.length != 32) throw new IllegalArgumentException("EDIT_REPLY toBlockHash32 != 32");
int cap = (4 + 32) + 2 + msgUtf8.length;
ByteBuffer bb = ByteBuffer.allocate(cap).order(ByteOrder.BIG_ENDIAN);
bb.putInt(toBlockGlobalNumber);
bb.put(toBlockHash32);
bb.putShort((short) msgUtf8.length);
bb.put(msgUtf8);
return bb.array();
} else {
throw new IllegalStateException("Unsupported Text subType: " + st);
}
}
/* ===================================================================== */
/* ========================== Helpers ================================== */
/* ===================================================================== */
private static String readStrictUtf8Len16(ByteBuffer bb, String fieldName) {
int len = Short.toUnsignedInt(bb.getShort());
if (len <= 0) throw new IllegalArgumentException(fieldName + " is empty");
if (bb.remaining() < len) throw new IllegalArgumentException(fieldName + " payload too short (len=" + len + ")");
byte[] bytes = new byte[len];
bb.get(bytes);
var decoder = StandardCharsets.UTF_8.newDecoder()
.onMalformedInput(CodingErrorAction.REPORT)
.onUnmappableCharacter(CodingErrorAction.REPORT);
try {
String s = decoder.decode(ByteBuffer.wrap(bytes)).toString();
if (s.isBlank()) throw new IllegalArgumentException(fieldName + " is blank");
return s;
} catch (CharacterCodingException e) {
throw new IllegalArgumentException(fieldName + " is not valid UTF-8", e);
}
}
private static void ensureMin(ByteBuffer bb, int need, String msg) {
if (bb.remaining() < need) throw new IllegalArgumentException(msg + " (need=" + need + ", remaining=" + bb.remaining() + ")");
}
private static void ensureNoTail(ByteBuffer bb, String ctx) {
if (bb.remaining() != 0) throw new IllegalArgumentException("Unexpected tail bytes for " + ctx + ", remaining=" + bb.remaining());
}
/* ====================== BodyHasLine ====================== */
@Override public int lineCode() { return lineCode; }
@Override public int prevLineBlockGlobalNumber() { return prevLineNumber; }
@Override public byte[] prevLineBlockHash32() {
if (prevLineHash32 == null) return null;
return Arrays.copyOf(prevLineHash32, 32);
}
@Override public int lineSeq() { return thisLineNumber; }
/* ====================== BodyHasTarget ===================== */
@Override public String toBchName() { return toBlockchainName; }
@Override public Integer toBlockGlobalNumber() { return toBlockGlobalNumber; }
@Override public byte[] toBlockHashBytes() { return toBlockHash32; }
/* ===================================================================== */
/* ===================== Удобные хелперы (для ChainState) =============== */
/* ===================================================================== */
/** true только для POST / EDIT_POST (т.е. это сообщение в линии канала). */
public boolean isLineMessage() {
int st = subType & 0xFFFF;
return st == (MsgSubType.TEXT_POST & 0xFFFF)
|| st == (MsgSubType.TEXT_EDIT_POST & 0xFFFF);
}
/** true только для EDIT_POST / EDIT_REPLY. */
public boolean isEditMessage() {
int st = subType & 0xFFFF;
return st == (MsgSubType.TEXT_EDIT_POST & 0xFFFF)
|| st == (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF);
}
/** true только для REPLY / EDIT_REPLY (т.е. “не в линии”). */
public boolean isReplyFamily() {
int st = subType & 0xFFFF;
return st == (MsgSubType.TEXT_REPLY & 0xFFFF)
|| st == (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF);
}
}
@@ -11,177 +11,374 @@ import java.util.Arrays;
import java.util.Objects;
/**
* Line-based TEXT body.
* TextLineBody — type=1, ver=1.
*
* subType:
* - POST (10)
* - EDIT_POST (11)
* - REPOST (50)
* - CHANNEL_META (90)
* - ENTRYPOINT (100)
* - EXERCISE (110)
* - SERVICE (120)
* - COURSE (130)
*
* Формат bodyBytes (BigEndian):
*
* POST / CHANNEL_META / ENTRYPOINT / EXERCISE / SERVICE / COURSE:
* line fields + text
* [4] lineCode
* [4] prevLineNumber
* [32] prevLineHash32
* [4] thisLineNumber
* [2] textLenBytes (uint16)
* [N] text UTF-8
*
* EDIT_POST (own-chain compact target):
* line fields + [4] targetBlockNumber + [32] targetHash + text
* EDIT_POST:
* [4] lineCode
* [4] prevLineNumber
* [32] prevLineHash32
* [4] thisLineNumber
* [4] toBlockGlobalNumber (int32)
* [32] toBlockHash32
* [2] textLenBytes (uint16)
* [N] text UTF-8
*
* REPOST (external target):
* line fields + [1]loginLen + login + [2]forkNumber + [4]blockNumber + [32]hash + text
* REPOST:
* [4] lineCode
* [4] prevLineNumber
* [32] prevLineHash32
* [4] thisLineNumber
* [1] toBlockchainNameLen (uint8)
* [N] toBlockchainName UTF-8
* [4] toBlockGlobalNumber (int32)
* [32] toBlockHash32
* [2] textLenBytes (uint16)
* [N] text UTF-8
*/
public final class TextLineBody implements BodyRecord, BodyHasLine, BodyHasTarget {
public static final short TYPE = 1;
public static final short VER = 1;
public static final short VER = 1;
public static final int KEY = ((TYPE & 0xFFFF) << 16) | (VER & 0xFFFF);
public final short subType;
public final short version;
public final short subType; // из header
public final short version; // из header (=1)
// line
public final int lineCode;
public final int prevLineNumber;
public final byte[] prevLineHash32;
public final byte[] prevLineHash32; // 32 (может быть нули)
public final int thisLineNumber;
public final String toLogin;
public final Integer toForkNumber;
public final Integer toBlockGlobalNumber;
public final byte[] toBlockHash32;
// target (для EDIT_POST / REPOST)
public final String toBlockchainName; // nullable для POST/EDIT_POST
public final Integer toBlockGlobalNumber; // nullable для POST
public final byte[] toBlockHash32; // nullable для POST
// text
public final String message;
/* ====================== parse from bytes ====================== */
public TextLineBody(short subType, short version, byte[] bodyBytes) {
Objects.requireNonNull(bodyBytes, "bodyBytes == null");
this.subType = subType;
this.version = version;
if ((version & 0xFFFF) != 1 || !isSupportedSubType(subType)) throw new IllegalArgumentException("Bad TextLineBody header");
if ((this.version & 0xFFFF) != (VER & 0xFFFF)) {
throw new IllegalArgumentException("TextLineBody version must be 1, got=" + (this.version & 0xFFFF));
}
int st = this.subType & 0xFFFF;
if (st != (MsgSubType.TEXT_POST & 0xFFFF)
&& st != (MsgSubType.TEXT_EDIT_POST & 0xFFFF)
&& st != (MsgSubType.TEXT_REPOST & 0xFFFF)
&& st != (MsgSubType.TEXT_CHANNEL_META & 0xFFFF)
&& st != (MsgSubType.TEXT_ENTRYPOINT & 0xFFFF)
&& st != (MsgSubType.TEXT_EXERCISE & 0xFFFF)
&& st != (MsgSubType.TEXT_SERVICE & 0xFFFF)
&& st != (MsgSubType.TEXT_COURSE & 0xFFFF)) {
throw new IllegalArgumentException("TextLineBody supports only POST/EDIT_POST/REPOST/CHANNEL_META, got subType=" + st);
}
ByteBuffer bb = ByteBuffer.wrap(bodyBytes).order(ByteOrder.BIG_ENDIAN);
BodyTargetSupport.ensureMin(bb, 4 + 4 + 32 + 4 + 2, "TextLineBody too short");
// минимум line + textLen(2)
ensureMin(bb, (4 + 4 + 32 + 4) + 2, "TextLineBody too short");
this.lineCode = bb.getInt();
this.prevLineNumber = bb.getInt();
this.prevLineHash32 = new byte[32]; bb.get(this.prevLineHash32);
this.prevLineHash32 = new byte[32];
bb.get(this.prevLineHash32);
this.thisLineNumber = bb.getInt();
int st = subType & 0xFFFF;
if (st == (MsgSubType.TEXT_EDIT_POST & 0xFFFF)) {
BodyTargetSupport.ensureMin(bb, 4 + 32 + 2, "EDIT_POST target missing");
this.toLogin = null;
this.toForkNumber = null;
this.toBlockGlobalNumber = bb.getInt();
this.toBlockHash32 = new byte[32]; bb.get(this.toBlockHash32);
BodyTargetSupport.validateCompact(this.toBlockGlobalNumber, this.toBlockHash32, "EDIT_POST");
// нужен target
ensureMin(bb, (4 + 32) + 2, "EDIT_POST missing target");
int tgtNum = bb.getInt();
byte[] tgtHash = new byte[32];
bb.get(tgtHash);
this.toBlockchainName = null;
this.toBlockGlobalNumber = tgtNum;
this.toBlockHash32 = tgtHash;
} else if (st == (MsgSubType.TEXT_REPOST & 0xFFFF)) {
BodyTargetSupport.ExternalTarget t = BodyTargetSupport.readExternal(bb, "REPOST", 2);
this.toLogin = t.login();
this.toForkNumber = t.forkNumber();
this.toBlockGlobalNumber = t.blockNumber();
this.toBlockHash32 = t.blockHash32();
ensureMin(bb, 1 + 1 + 4 + 32 + 2, "REPOST missing target");
int nameLen = Byte.toUnsignedInt(bb.get());
if (nameLen <= 0) throw new IllegalArgumentException("REPOST toBlockchainNameLen is 0");
ensureMin(bb, nameLen + 4 + 32 + 2, "REPOST payload too short");
byte[] nameBytes = new byte[nameLen];
bb.get(nameBytes);
this.toBlockchainName = new String(nameBytes, StandardCharsets.UTF_8);
this.toBlockGlobalNumber = bb.getInt();
this.toBlockHash32 = new byte[32];
bb.get(this.toBlockHash32);
} else {
this.toLogin = null;
this.toForkNumber = null;
this.toBlockchainName = null;
this.toBlockGlobalNumber = null;
this.toBlockHash32 = null;
}
boolean allowEmpty = st == (MsgSubType.TEXT_EDIT_POST & 0xFFFF) || st == (MsgSubType.TEXT_CHANNEL_META & 0xFFFF) || st == (MsgSubType.TEXT_CHANNEL_DELETE & 0xFFFF);
this.message = readText(bb, allowEmpty);
if (bb.hasRemaining()) throw new IllegalArgumentException("Unexpected TextLineBody tail");
this.message = readStrictUtf8Len16(bb, "TextLineBody text",
st == (MsgSubType.TEXT_EDIT_POST & 0xFFFF) || st == (MsgSubType.TEXT_CHANNEL_META & 0xFFFF));
ensureNoTail(bb, "TextLineBody");
}
/* ====================== manual ctor ====================== */
public TextLineBody(int lineCode,
int prevLineNumber,
byte[] prevLineHash32,
int thisLineNumber,
short subType,
String toLogin,
Integer toForkNumber,
Integer toBlockGlobalNumber,
byte[] toBlockHash32,
String toBlockchainName,
String message) {
Objects.requireNonNull(message, "message == null");
if (!isSupportedSubType(subType)) throw new IllegalArgumentException("Bad TextLineBody subtype");
int st = subType & 0xFFFF;
if (st != (MsgSubType.TEXT_POST & 0xFFFF)
&& st != (MsgSubType.TEXT_EDIT_POST & 0xFFFF)
&& st != (MsgSubType.TEXT_REPOST & 0xFFFF)
&& st != (MsgSubType.TEXT_CHANNEL_META & 0xFFFF)
&& st != (MsgSubType.TEXT_ENTRYPOINT & 0xFFFF)
&& st != (MsgSubType.TEXT_EXERCISE & 0xFFFF)
&& st != (MsgSubType.TEXT_SERVICE & 0xFFFF)
&& st != (MsgSubType.TEXT_COURSE & 0xFFFF)) {
throw new IllegalArgumentException("TextLineBody supports only POST/EDIT_POST/REPOST/CHANNEL_META");
}
if (lineCode < 0) throw new IllegalArgumentException("lineCode < 0");
if (requiresNonBlankMessage(st) && message.isBlank()) {
throw new IllegalArgumentException("message is blank");
}
this.subType = subType;
this.version = VER;
this.lineCode = lineCode;
this.prevLineNumber = prevLineNumber;
this.prevLineHash32 = prevLineHash32 == null ? new byte[32] : Arrays.copyOf(prevLineHash32, 32);
this.prevLineHash32 = (prevLineHash32 == null ? new byte[32] : Arrays.copyOf(prevLineHash32, 32));
this.thisLineNumber = thisLineNumber;
this.toLogin = toLogin;
this.toForkNumber = toForkNumber;
this.toBlockGlobalNumber = toBlockGlobalNumber;
this.toBlockHash32 = toBlockHash32 == null ? null : Arrays.copyOf(toBlockHash32, 32);
this.message = message;
check();
}
@Override public TextLineBody check() {
if (!isSupportedSubType(subType)) throw new IllegalArgumentException("Bad TextLineBody subtype");
if (lineCode < 0) throw new IllegalArgumentException("lineCode < 0");
if (prevLineHash32 == null || prevLineHash32.length != 32) throw new IllegalArgumentException("prevLineHash32 invalid");
int st = subType & 0xFFFF;
if (st == (MsgSubType.TEXT_EDIT_POST & 0xFFFF)) {
if (toLogin != null || toForkNumber != null) throw new IllegalArgumentException("EDIT_POST must not contain login/fork target");
BodyTargetSupport.validateCompact(toBlockGlobalNumber, toBlockHash32, "EDIT_POST");
if (message == null) throw new IllegalArgumentException("EDIT_POST message is null");
Objects.requireNonNull(toBlockGlobalNumber, "toBlockGlobalNumber == null");
Objects.requireNonNull(toBlockHash32, "toBlockHash32 == null");
if (toBlockGlobalNumber < 0) throw new IllegalArgumentException("toBlockGlobalNumber < 0");
if (toBlockHash32.length != 32) throw new IllegalArgumentException("toBlockHash32 != 32");
this.toBlockchainName = null;
this.toBlockGlobalNumber = toBlockGlobalNumber;
this.toBlockHash32 = Arrays.copyOf(toBlockHash32, 32);
} else if (st == (MsgSubType.TEXT_REPOST & 0xFFFF)) {
BodyTargetSupport.validateExternal(toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "REPOST");
if (message == null || message.isBlank()) throw new IllegalArgumentException("REPOST message is blank");
Objects.requireNonNull(toBlockchainName, "toBlockchainName == null");
if (toBlockchainName.isBlank()) throw new IllegalArgumentException("toBlockchainName is blank");
Objects.requireNonNull(toBlockGlobalNumber, "toBlockGlobalNumber == null");
Objects.requireNonNull(toBlockHash32, "toBlockHash32 == null");
if (toBlockGlobalNumber < 0) throw new IllegalArgumentException("toBlockGlobalNumber < 0");
if (toBlockHash32.length != 32) throw new IllegalArgumentException("toBlockHash32 != 32");
this.toBlockchainName = toBlockchainName;
this.toBlockGlobalNumber = toBlockGlobalNumber;
this.toBlockHash32 = Arrays.copyOf(toBlockHash32, 32);
} else {
if (toLogin != null || toForkNumber != null || toBlockGlobalNumber != null || toBlockHash32 != null) {
throw new IllegalArgumentException("Non-target text body must not contain target fields");
}
this.toBlockchainName = null;
this.toBlockGlobalNumber = null;
this.toBlockHash32 = null;
}
this.message = message;
}
@Override
public TextLineBody check() {
int st = subType & 0xFFFF;
if (st != (MsgSubType.TEXT_POST & 0xFFFF)
&& st != (MsgSubType.TEXT_EDIT_POST & 0xFFFF)
&& st != (MsgSubType.TEXT_REPOST & 0xFFFF)
&& st != (MsgSubType.TEXT_CHANNEL_META & 0xFFFF)
&& st != (MsgSubType.TEXT_ENTRYPOINT & 0xFFFF)
&& st != (MsgSubType.TEXT_EXERCISE & 0xFFFF)
&& st != (MsgSubType.TEXT_SERVICE & 0xFFFF)
&& st != (MsgSubType.TEXT_COURSE & 0xFFFF))
throw new IllegalArgumentException("Bad TextLineBody subType: " + st);
if (lineCode < 0) throw new IllegalArgumentException("lineCode < 0");
if (prevLineHash32 == null || prevLineHash32.length != 32)
throw new IllegalArgumentException("prevLineHash32 invalid");
if (st == (MsgSubType.TEXT_EDIT_POST & 0xFFFF)) {
if (message == null) throw new IllegalArgumentException("EDIT_POST message is null");
if (toBlockGlobalNumber == null || toBlockGlobalNumber < 0)
throw new IllegalArgumentException("EDIT_POST toBlockGlobalNumber invalid");
if (toBlockHash32 == null || toBlockHash32.length != 32)
throw new IllegalArgumentException("EDIT_POST toBlockHash32 invalid");
if (toBlockchainName != null)
throw new IllegalArgumentException("EDIT_POST must not contain toBlockchainName");
} else if (st == (MsgSubType.TEXT_REPOST & 0xFFFF)) {
if (message == null || message.isBlank())
throw new IllegalArgumentException("REPOST message is blank");
if (toBlockchainName == null || toBlockchainName.isBlank())
throw new IllegalArgumentException("REPOST toBlockchainName is blank");
if (toBlockGlobalNumber == null || toBlockGlobalNumber < 0)
throw new IllegalArgumentException("REPOST toBlockGlobalNumber invalid");
if (toBlockHash32 == null || toBlockHash32.length != 32)
throw new IllegalArgumentException("REPOST toBlockHash32 invalid");
} else {
if (st == (MsgSubType.TEXT_CHANNEL_META & 0xFFFF)) {
if (message == null) throw new IllegalArgumentException("CHANNEL_META message is null");
} else if (st == (MsgSubType.TEXT_CHANNEL_DELETE & 0xFFFF)) {
if (message == null || !message.isEmpty()) throw new IllegalArgumentException("CHANNEL_DELETE message must be empty");
} else if (message == null || message.isBlank()) {
} else if (requiresNonBlankMessage(st) && (message == null || message.isBlank())) {
throw new IllegalArgumentException("Text message is blank");
} else if (message == null) {
throw new IllegalArgumentException("Text message is null");
}
if (toBlockchainName != null || toBlockGlobalNumber != null || toBlockHash32 != null)
throw new IllegalArgumentException("POST/CHANNEL_META must not contain target fields");
}
if (message.getBytes(StandardCharsets.UTF_8).length > 65535) throw new IllegalArgumentException("Text too long");
return this;
}
@Override public byte[] toBytes() {
check();
byte[] text = message.getBytes(StandardCharsets.UTF_8);
int st = subType & 0xFFFF;
int targetSize = 0;
if (st == (MsgSubType.TEXT_EDIT_POST & 0xFFFF)) targetSize = 4 + 32;
else if (st == (MsgSubType.TEXT_REPOST & 0xFFFF)) targetSize = BodyTargetSupport.externalSize(toLogin);
@Override
public byte[] toBytes() {
byte[] msgUtf8 = message.getBytes(StandardCharsets.UTF_8);
if (msgUtf8.length > 65535) throw new IllegalArgumentException("Text too long (>65535 bytes)");
ByteBuffer bb = ByteBuffer.allocate(4 + 4 + 32 + 4 + targetSize + 2 + text.length).order(ByteOrder.BIG_ENDIAN);
bb.putInt(lineCode).putInt(prevLineNumber).put(prevLineHash32).putInt(thisLineNumber);
if (st == (MsgSubType.TEXT_EDIT_POST & 0xFFFF)) {
bb.putInt(toBlockGlobalNumber).put(toBlockHash32);
} else if (st == (MsgSubType.TEXT_REPOST & 0xFFFF)) {
BodyTargetSupport.writeExternal(bb, toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "REPOST");
int st = subType & 0xFFFF;
if (requiresNonBlankMessage(st) && msgUtf8.length == 0) {
throw new IllegalArgumentException("Text payload is empty");
}
bb.putShort((short) text.length).put(text);
int cap;
if (st == (MsgSubType.TEXT_POST & 0xFFFF)
|| st == (MsgSubType.TEXT_CHANNEL_META & 0xFFFF)
|| st == (MsgSubType.TEXT_ENTRYPOINT & 0xFFFF)
|| st == (MsgSubType.TEXT_EXERCISE & 0xFFFF)
|| st == (MsgSubType.TEXT_SERVICE & 0xFFFF)
|| st == (MsgSubType.TEXT_COURSE & 0xFFFF)) {
cap = (4 + 4 + 32 + 4) + 2 + msgUtf8.length;
} else if (st == (MsgSubType.TEXT_EDIT_POST & 0xFFFF)) {
// EDIT_POST
if (toBlockGlobalNumber == null) throw new IllegalArgumentException("EDIT_POST missing toBlockGlobalNumber");
if (toBlockHash32 == null || toBlockHash32.length != 32) throw new IllegalArgumentException("EDIT_POST toBlockHash32 != 32");
cap = (4 + 4 + 32 + 4) + (4 + 32) + 2 + msgUtf8.length;
} else {
if (toBlockchainName == null) throw new IllegalArgumentException("REPOST missing toBlockchainName");
byte[] nameUtf8 = toBlockchainName.getBytes(StandardCharsets.UTF_8);
if (nameUtf8.length == 0 || nameUtf8.length > 255) {
throw new IllegalArgumentException("REPOST toBlockchainName utf8 len must be 1..255");
}
if (toBlockGlobalNumber == null) throw new IllegalArgumentException("REPOST missing toBlockGlobalNumber");
if (toBlockHash32 == null || toBlockHash32.length != 32) throw new IllegalArgumentException("REPOST toBlockHash32 != 32");
cap = (4 + 4 + 32 + 4) + (1 + nameUtf8.length + 4 + 32) + 2 + msgUtf8.length;
}
ByteBuffer bb = ByteBuffer.allocate(cap).order(ByteOrder.BIG_ENDIAN);
bb.putInt(lineCode);
bb.putInt(prevLineNumber);
bb.put(prevLineHash32 == null ? new byte[32] : Arrays.copyOf(prevLineHash32, 32));
bb.putInt(thisLineNumber);
if (st == (MsgSubType.TEXT_EDIT_POST & 0xFFFF)) {
bb.putInt(toBlockGlobalNumber);
bb.put(toBlockHash32);
} else if (st == (MsgSubType.TEXT_REPOST & 0xFFFF)) {
byte[] nameUtf8 = toBlockchainName.getBytes(StandardCharsets.UTF_8);
bb.put((byte) nameUtf8.length);
bb.put(nameUtf8);
bb.putInt(toBlockGlobalNumber);
bb.put(toBlockHash32);
}
bb.putShort((short) msgUtf8.length);
bb.put(msgUtf8);
return bb.array();
}
/* ====================== BodyHasLine ====================== */
@Override public int lineCode() { return lineCode; }
@Override public int prevLineBlockGlobalNumber() { return prevLineNumber; }
@Override public byte[] prevLineBlockHash32() { return Arrays.copyOf(prevLineHash32, 32); }
@Override public int lineSeq() { return thisLineNumber; }
@Override public String toLogin() { return toLogin; }
@Override public Integer toForkNumber() { return toForkNumber; }
@Override public Integer toBlockGlobalNumber() { return toBlockGlobalNumber; }
@Override public byte[] toBlockHashBytes() { return toBlockHash32 == null ? null : Arrays.copyOf(toBlockHash32, 32); }
public boolean isEditPost() { return (subType & 0xFFFF) == (MsgSubType.TEXT_EDIT_POST & 0xFFFF); }
private static boolean isSupportedSubType(short subType) {
int st = subType & 0xFFFF;
return st == (MsgSubType.TEXT_POST & 0xFFFF) || st == (MsgSubType.TEXT_EDIT_POST & 0xFFFF)
|| st == (MsgSubType.TEXT_REPOST & 0xFFFF) || st == (MsgSubType.TEXT_CHANNEL_META & 0xFFFF)
|| st == (MsgSubType.TEXT_CHANNEL_DELETE & 0xFFFF)
|| st == (MsgSubType.TEXT_ENTRYPOINT & 0xFFFF) || st == (MsgSubType.TEXT_EXERCISE & 0xFFFF)
|| st == (MsgSubType.TEXT_SERVICE & 0xFFFF) || st == (MsgSubType.TEXT_COURSE & 0xFFFF);
/* ====================== BodyHasTarget ===================== */
@Override public String toBchName() { return toBlockchainName; }
@Override public Integer toBlockGlobalNumber() { return toBlockGlobalNumber; }
@Override public byte[] toBlockHashBytes() { return toBlockHash32; }
/* ====================== helpers ====================== */
public boolean isEditPost() {
return (subType & 0xFFFF) == (MsgSubType.TEXT_EDIT_POST & 0xFFFF);
}
private static String readText(ByteBuffer bb, boolean allowEmpty) {
if (bb.remaining() < 2) throw new IllegalArgumentException("Text length missing");
private static boolean requiresNonBlankMessage(int st) {
return st == (MsgSubType.TEXT_POST & 0xFFFF)
|| st == (MsgSubType.TEXT_REPOST & 0xFFFF)
|| st == (MsgSubType.TEXT_ENTRYPOINT & 0xFFFF)
|| st == (MsgSubType.TEXT_EXERCISE & 0xFFFF)
|| st == (MsgSubType.TEXT_SERVICE & 0xFFFF)
|| st == (MsgSubType.TEXT_COURSE & 0xFFFF);
}
private static String readStrictUtf8Len16(ByteBuffer bb, String fieldName, boolean allowEmpty) {
int len = Short.toUnsignedInt(bb.getShort());
if (len == 0) { if (allowEmpty) return ""; throw new IllegalArgumentException("Text is empty"); }
if (bb.remaining() < len) throw new IllegalArgumentException("Text payload too short");
byte[] bytes = new byte[len]; bb.get(bytes);
var dec = StandardCharsets.UTF_8.newDecoder().onMalformedInput(CodingErrorAction.REPORT).onUnmappableCharacter(CodingErrorAction.REPORT);
try { String s = dec.decode(ByteBuffer.wrap(bytes)).toString(); if (!allowEmpty && s.isBlank()) throw new IllegalArgumentException("Text blank"); return s; }
catch (CharacterCodingException e) { throw new IllegalArgumentException("Text invalid UTF-8", e); }
if (len == 0) {
if (allowEmpty) return "";
throw new IllegalArgumentException(fieldName + " is empty");
}
if (bb.remaining() < len) throw new IllegalArgumentException(fieldName + " payload too short (len=" + len + ")");
byte[] bytes = new byte[len];
bb.get(bytes);
var decoder = StandardCharsets.UTF_8.newDecoder()
.onMalformedInput(CodingErrorAction.REPORT)
.onUnmappableCharacter(CodingErrorAction.REPORT);
try {
String s = decoder.decode(ByteBuffer.wrap(bytes)).toString();
if (!allowEmpty && s.isBlank()) throw new IllegalArgumentException(fieldName + " is blank");
return s;
} catch (CharacterCodingException e) {
throw new IllegalArgumentException(fieldName + " is not valid UTF-8", e);
}
}
private static void ensureMin(ByteBuffer bb, int need, String msg) {
if (bb.remaining() < need) throw new IllegalArgumentException(msg + " (need=" + need + ", remaining=" + bb.remaining() + ")");
}
private static void ensureNoTail(ByteBuffer bb, String ctx) {
if (bb.remaining() != 0) throw new IllegalArgumentException("Unexpected tail bytes for " + ctx + ", remaining=" + bb.remaining());
}
}
@@ -10,16 +10,29 @@ import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Objects;
/** TEXT_RATING. External target = login + forkNumber + blockNumber + hash32. */
/**
* TextRatingBody — type=1, ver=1.
*
* subType:
* - RATING (30)
*
* Формат bodyBytes (BigEndian):
* [1] toBlockchainNameLen (uint8)
* [N] toBlockchainName UTF-8
* [4] toBlockGlobalNumber
* [32] toBlockHash32
* [2] textLenBytes (uint16)
* [M] text UTF-8
*/
public final class TextRatingBody implements BodyRecord, BodyHasTarget {
public static final short TYPE = 1;
public static final short VER = 1;
public static final int KEY = ((TYPE & 0xFFFF) << 16) | (VER & 0xFFFF);
public final short subType;
public final short version;
public final String toLogin;
public final int toForkNumber;
public final String toBlockchainName;
public final int toBlockGlobalNumber;
public final byte[] toBlockHash32;
public final String message;
@@ -28,60 +41,117 @@ public final class TextRatingBody implements BodyRecord, BodyHasTarget {
Objects.requireNonNull(bodyBytes, "bodyBytes == null");
this.subType = subType;
this.version = version;
if ((version & 0xFFFF) != (VER & 0xFFFF)) throw new IllegalArgumentException("TextRatingBody version must be 1");
if ((subType & 0xFFFF) != (MsgSubType.TEXT_RATING & 0xFFFF)) throw new IllegalArgumentException("TextRatingBody supports only TEXT_RATING");
if ((version & 0xFFFF) != (VER & 0xFFFF)) {
throw new IllegalArgumentException("TextRatingBody version must be 1, got=" + (version & 0xFFFF));
}
if ((subType & 0xFFFF) != (MsgSubType.TEXT_RATING & 0xFFFF)) {
throw new IllegalArgumentException("TextRatingBody supports only TEXT_RATING");
}
ByteBuffer bb = ByteBuffer.wrap(bodyBytes).order(ByteOrder.BIG_ENDIAN);
BodyTargetSupport.ExternalTarget t = BodyTargetSupport.readExternal(bb, "RATING", 2);
this.toLogin = t.login();
this.toForkNumber = t.forkNumber();
this.toBlockGlobalNumber = t.blockNumber();
this.toBlockHash32 = t.blockHash32();
this.message = readText(bb);
if (bb.hasRemaining()) throw new IllegalArgumentException("Unexpected RATING tail");
ensureMin(bb, 1 + 1 + 4 + 32 + 2, "RATING too short");
int nameLen = Byte.toUnsignedInt(bb.get());
if (nameLen <= 0) throw new IllegalArgumentException("RATING toBlockchainNameLen is 0");
ensureMin(bb, nameLen + 4 + 32 + 2, "RATING payload too short");
byte[] nameBytes = new byte[nameLen];
bb.get(nameBytes);
this.toBlockchainName = new String(nameBytes, StandardCharsets.UTF_8);
this.toBlockGlobalNumber = bb.getInt();
this.toBlockHash32 = new byte[32];
bb.get(this.toBlockHash32);
this.message = readStrictUtf8Len16(bb, "TextRatingBody text");
ensureNoTail(bb, "TextRatingBody");
}
public TextRatingBody(String toLogin, int toForkNumber, int toBlockGlobalNumber, byte[] toBlockHash32, String message) {
public TextRatingBody(String toBlockchainName, int toBlockGlobalNumber, byte[] toBlockHash32, String message) {
Objects.requireNonNull(toBlockchainName, "toBlockchainName == null");
Objects.requireNonNull(toBlockHash32, "toBlockHash32 == null");
Objects.requireNonNull(message, "message == null");
if (toBlockchainName.isBlank()) throw new IllegalArgumentException("toBlockchainName is blank");
if (toBlockGlobalNumber < 0) throw new IllegalArgumentException("toBlockGlobalNumber < 0");
if (toBlockHash32.length != 32) throw new IllegalArgumentException("toBlockHash32 != 32");
if (message.isBlank()) throw new IllegalArgumentException("message is blank");
BodyTargetSupport.validateExternal(toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "RATING");
this.subType = MsgSubType.TEXT_RATING;
this.version = VER;
this.toLogin = toLogin;
this.toForkNumber = toForkNumber;
this.toBlockchainName = toBlockchainName;
this.toBlockGlobalNumber = toBlockGlobalNumber;
this.toBlockHash32 = Arrays.copyOf(toBlockHash32, 32);
this.message = message;
}
@Override public TextRatingBody check() {
if ((subType & 0xFFFF) != (MsgSubType.TEXT_RATING & 0xFFFF)) throw new IllegalArgumentException("Bad RATING subType");
BodyTargetSupport.validateExternal(toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "RATING");
@Override
public TextRatingBody check() {
if ((subType & 0xFFFF) != (MsgSubType.TEXT_RATING & 0xFFFF)) {
throw new IllegalArgumentException("Bad TextRatingBody subType: " + (subType & 0xFFFF));
}
if (toBlockchainName == null || toBlockchainName.isBlank()) {
throw new IllegalArgumentException("RATING toBlockchainName is blank");
}
if (toBlockGlobalNumber < 0) throw new IllegalArgumentException("toBlockGlobalNumber < 0");
if (toBlockHash32 == null || toBlockHash32.length != 32) {
throw new IllegalArgumentException("toBlockHash32 invalid");
}
if (message == null || message.isBlank()) throw new IllegalArgumentException("message is blank");
if (message.getBytes(StandardCharsets.UTF_8).length > 65535) throw new IllegalArgumentException("Text too long");
return this;
}
@Override public byte[] toBytes() {
check();
byte[] text = message.getBytes(StandardCharsets.UTF_8);
ByteBuffer bb = ByteBuffer.allocate(BodyTargetSupport.externalSize(toLogin) + 2 + text.length).order(ByteOrder.BIG_ENDIAN);
BodyTargetSupport.writeExternal(bb, toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "RATING");
bb.putShort((short) text.length).put(text);
@Override
public byte[] toBytes() {
byte[] msgUtf8 = message.getBytes(StandardCharsets.UTF_8);
if (msgUtf8.length == 0) throw new IllegalArgumentException("Text payload is empty");
if (msgUtf8.length > 65535) throw new IllegalArgumentException("Text too long (>65535 bytes)");
byte[] nameUtf8 = toBlockchainName.getBytes(StandardCharsets.UTF_8);
if (nameUtf8.length == 0 || nameUtf8.length > 255) {
throw new IllegalArgumentException("RATING toBlockchainName utf8 len must be 1..255");
}
ByteBuffer bb = ByteBuffer.allocate(1 + nameUtf8.length + 4 + 32 + 2 + msgUtf8.length)
.order(ByteOrder.BIG_ENDIAN);
bb.put((byte) nameUtf8.length);
bb.put(nameUtf8);
bb.putInt(toBlockGlobalNumber);
bb.put(toBlockHash32);
bb.putShort((short) msgUtf8.length);
bb.put(msgUtf8);
return bb.array();
}
@Override public String toLogin() { return toLogin; }
@Override public Integer toForkNumber() { return toForkNumber; }
@Override public String toBchName() { return toBlockchainName; }
@Override public Integer toBlockGlobalNumber() { return toBlockGlobalNumber; }
@Override public byte[] toBlockHashBytes() { return Arrays.copyOf(toBlockHash32, 32); }
@Override public byte[] toBlockHashBytes() { return toBlockHash32; }
private static String readText(ByteBuffer bb) {
if (bb.remaining() < 2) throw new IllegalArgumentException("RATING text length missing");
private static String readStrictUtf8Len16(ByteBuffer bb, String fieldName) {
int len = Short.toUnsignedInt(bb.getShort());
if (len <= 0 || bb.remaining() < len) throw new IllegalArgumentException("RATING text invalid");
byte[] bytes = new byte[len]; bb.get(bytes);
var dec = StandardCharsets.UTF_8.newDecoder().onMalformedInput(CodingErrorAction.REPORT).onUnmappableCharacter(CodingErrorAction.REPORT);
try { String s = dec.decode(ByteBuffer.wrap(bytes)).toString(); if (s.isBlank()) throw new IllegalArgumentException("RATING text blank"); return s; }
catch (CharacterCodingException e) { throw new IllegalArgumentException("RATING text invalid UTF-8", e); }
if (len == 0) throw new IllegalArgumentException(fieldName + " is empty");
if (bb.remaining() < len) throw new IllegalArgumentException(fieldName + " payload too short (len=" + len + ")");
byte[] bytes = new byte[len];
bb.get(bytes);
var decoder = StandardCharsets.UTF_8.newDecoder()
.onMalformedInput(CodingErrorAction.REPORT)
.onUnmappableCharacter(CodingErrorAction.REPORT);
try {
String s = decoder.decode(ByteBuffer.wrap(bytes)).toString();
if (s.isBlank()) throw new IllegalArgumentException(fieldName + " is blank");
return s;
} catch (CharacterCodingException e) {
throw new IllegalArgumentException(fieldName + " is not valid UTF-8", e);
}
}
private static void ensureMin(ByteBuffer bb, int need, String msg) {
if (bb.remaining() < need) throw new IllegalArgumentException(msg + " (need=" + need + ", remaining=" + bb.remaining() + ")");
}
private static void ensureNoTail(ByteBuffer bb, String ctx) {
if (bb.remaining() != 0) throw new IllegalArgumentException("Unexpected tail bytes for " + ctx + ", remaining=" + bb.remaining());
}
}
@@ -11,111 +11,241 @@ import java.util.Arrays;
import java.util.Objects;
/**
* TEXT_REPLY / TEXT_EDIT_REPLY.
* REPLY external target: login + forkNumber + blockNumber + hash32.
* EDIT_REPLY compact own-chain target: blockNumber + hash32.
* TextReplyBody — type=1, ver=1.
*
* subType:
* - REPLY (20)
* - EDIT_REPLY (21)
*
* Форматы bodyBytes (BigEndian):
*
* REPLY:
* [1] toBlockchainNameLen (uint8)
* [N] toBlockchainName UTF-8
* [4] toBlockGlobalNumber
* [32] toBlockHash32
* [2] textLenBytes (uint16)
* [M] text UTF-8
*
* EDIT_REPLY:
* [4] toBlockGlobalNumber
* [32] toBlockHash32
* [2] textLenBytes (uint16)
* [N] text UTF-8
*/
public final class TextReplyBody implements BodyRecord, BodyHasTarget {
public static final short TYPE = 1;
public static final short VER = 1;
public static final short VER = 1;
public static final int KEY = ((TYPE & 0xFFFF) << 16) | (VER & 0xFFFF);
public final short subType;
public final short version;
public final String toLogin;
public final Integer toForkNumber;
public final short subType; // из header
public final short version; // (=1)
// target
public final String toBlockchainName; // nullable для EDIT_REPLY
public final int toBlockGlobalNumber;
public final byte[] toBlockHash32;
public final byte[] toBlockHash32; // 32
// text
public final String message;
public TextReplyBody(short subType, short version, byte[] bodyBytes) {
Objects.requireNonNull(bodyBytes, "bodyBytes == null");
this.subType = subType;
this.version = version;
if ((version & 0xFFFF) != (VER & 0xFFFF)) throw new IllegalArgumentException("TextReplyBody version must be 1");
int st = subType & 0xFFFF;
if (st != (MsgSubType.TEXT_REPLY & 0xFFFF) && st != (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF)) throw new IllegalArgumentException("Bad reply subtype");
if ((this.version & 0xFFFF) != (VER & 0xFFFF)) {
throw new IllegalArgumentException("TextReplyBody version must be 1, got=" + (this.version & 0xFFFF));
}
int st = this.subType & 0xFFFF;
if (st != (MsgSubType.TEXT_REPLY & 0xFFFF) && st != (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF)) {
throw new IllegalArgumentException("TextReplyBody supports only REPLY/EDIT_REPLY, got subType=" + st);
}
ByteBuffer bb = ByteBuffer.wrap(bodyBytes).order(ByteOrder.BIG_ENDIAN);
if (st == (MsgSubType.TEXT_REPLY & 0xFFFF)) {
BodyTargetSupport.ExternalTarget t = BodyTargetSupport.readExternal(bb, "REPLY", 2);
this.toLogin = t.login();
this.toForkNumber = t.forkNumber();
this.toBlockGlobalNumber = t.blockNumber();
this.toBlockHash32 = t.blockHash32();
} else {
BodyTargetSupport.ensureMin(bb, 4 + 32 + 2, "EDIT_REPLY too short");
this.toLogin = null;
this.toForkNumber = null;
// минимум: nameLen[1]+name[1]+global[4]+hash[32]+textLen[2]
ensureMin(bb, 1 + 1 + 4 + 32 + 2, "REPLY too short");
int nameLen = Byte.toUnsignedInt(bb.get());
if (nameLen <= 0) throw new IllegalArgumentException("REPLY toBlockchainNameLen is 0");
ensureMin(bb, nameLen + 4 + 32 + 2, "REPLY payload too short");
byte[] nameBytes = new byte[nameLen];
bb.get(nameBytes);
this.toBlockchainName = new String(nameBytes, StandardCharsets.UTF_8);
this.toBlockGlobalNumber = bb.getInt();
this.toBlockHash32 = new byte[32];
bb.get(this.toBlockHash32);
} else {
// EDIT_REPLY: target без имени
ensureMin(bb, (4 + 32) + 2, "EDIT_REPLY too short");
this.toBlockchainName = null;
this.toBlockGlobalNumber = bb.getInt();
this.toBlockHash32 = new byte[32];
bb.get(this.toBlockHash32);
BodyTargetSupport.validateCompact(this.toBlockGlobalNumber, this.toBlockHash32, "EDIT_REPLY");
}
this.message = readText(bb, st == (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF));
if (bb.hasRemaining()) throw new IllegalArgumentException("Unexpected TextReplyBody tail");
this.message = readStrictUtf8Len16(bb, "TextReplyBody text", st == (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF));
ensureNoTail(bb, "TextReplyBody");
}
public TextReplyBody(short subType, String toLogin, Integer toForkNumber, int toBlockGlobalNumber, byte[] toBlockHash32, String message) {
public TextReplyBody(short subType,
int toBlockGlobalNumber,
byte[] toBlockHash32,
String toBlockchainName,
String message) {
Objects.requireNonNull(message, "message == null");
Objects.requireNonNull(toBlockHash32, "toBlockHash32 == null");
int st = subType & 0xFFFF;
if (st != (MsgSubType.TEXT_REPLY & 0xFFFF) && st != (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF)) throw new IllegalArgumentException("Bad reply subtype");
if (st == (MsgSubType.TEXT_REPLY & 0xFFFF)) {
if (message.isBlank()) throw new IllegalArgumentException("REPLY message is blank");
BodyTargetSupport.validateExternal(toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "REPLY");
} else {
if (toLogin != null || toForkNumber != null) throw new IllegalArgumentException("EDIT_REPLY must not contain login/fork target");
BodyTargetSupport.validateCompact(toBlockGlobalNumber, toBlockHash32, "EDIT_REPLY");
if (st != (MsgSubType.TEXT_REPLY & 0xFFFF) && st != (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF)) {
throw new IllegalArgumentException("TextReplyBody supports only REPLY/EDIT_REPLY");
}
if (st == (MsgSubType.TEXT_REPLY & 0xFFFF) && message.isBlank()) {
throw new IllegalArgumentException("message is blank");
}
if (toBlockGlobalNumber < 0) throw new IllegalArgumentException("toBlockGlobalNumber < 0");
if (toBlockHash32.length != 32) throw new IllegalArgumentException("toBlockHash32 != 32");
if (st == (MsgSubType.TEXT_REPLY & 0xFFFF)) {
Objects.requireNonNull(toBlockchainName, "toBlockchainName == null");
if (toBlockchainName.isBlank()) throw new IllegalArgumentException("toBlockchainName is blank");
this.toBlockchainName = toBlockchainName;
} else {
// EDIT_REPLY: имя не хранить
this.toBlockchainName = null;
}
this.subType = subType;
this.version = VER;
this.toLogin = toLogin;
this.toForkNumber = toForkNumber;
this.toBlockGlobalNumber = toBlockGlobalNumber;
this.toBlockHash32 = Arrays.copyOf(toBlockHash32, 32);
this.message = message;
}
@Override public TextReplyBody check() {
@Override
public TextReplyBody check() {
int st = subType & 0xFFFF;
if (st != (MsgSubType.TEXT_REPLY & 0xFFFF) && st != (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF))
throw new IllegalArgumentException("Bad TextReplyBody subType: " + st);
if (toBlockGlobalNumber < 0)
throw new IllegalArgumentException("toBlockGlobalNumber < 0");
if (toBlockHash32 == null || toBlockHash32.length != 32)
throw new IllegalArgumentException("toBlockHash32 invalid");
if (st == (MsgSubType.TEXT_REPLY & 0xFFFF)) {
BodyTargetSupport.validateExternal(toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "REPLY");
if (message == null || message.isBlank()) throw new IllegalArgumentException("REPLY message is blank");
} else if (st == (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF)) {
if (toLogin != null || toForkNumber != null) throw new IllegalArgumentException("EDIT_REPLY must not contain login/fork target");
BodyTargetSupport.validateCompact(toBlockGlobalNumber, toBlockHash32, "EDIT_REPLY");
if (message == null || message.isBlank())
throw new IllegalArgumentException("Text message is blank");
if (toBlockchainName == null || toBlockchainName.isBlank())
throw new IllegalArgumentException("REPLY toBlockchainName is blank");
} else {
if (message == null) throw new IllegalArgumentException("EDIT_REPLY message is null");
} else throw new IllegalArgumentException("Bad reply subtype");
if (message.getBytes(StandardCharsets.UTF_8).length > 65535) throw new IllegalArgumentException("Text too long");
if (toBlockchainName != null)
throw new IllegalArgumentException("EDIT_REPLY must not contain toBlockchainName");
}
return this;
}
@Override public byte[] toBytes() {
check();
byte[] text = message.getBytes(StandardCharsets.UTF_8);
boolean reply = (subType & 0xFFFF) == (MsgSubType.TEXT_REPLY & 0xFFFF);
int targetSize = reply ? BodyTargetSupport.externalSize(toLogin) : 4 + 32;
ByteBuffer bb = ByteBuffer.allocate(targetSize + 2 + text.length).order(ByteOrder.BIG_ENDIAN);
if (reply) BodyTargetSupport.writeExternal(bb, toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "REPLY");
else bb.putInt(toBlockGlobalNumber).put(toBlockHash32);
bb.putShort((short) text.length).put(text);
@Override
public byte[] toBytes() {
byte[] msgUtf8 = message.getBytes(StandardCharsets.UTF_8);
if (msgUtf8.length > 65535) throw new IllegalArgumentException("Text too long (>65535 bytes)");
int st = subType & 0xFFFF;
if (st == (MsgSubType.TEXT_REPLY & 0xFFFF) && msgUtf8.length == 0) {
throw new IllegalArgumentException("Text payload is empty");
}
if (st == (MsgSubType.TEXT_REPLY & 0xFFFF)) {
if (toBlockchainName == null) throw new IllegalArgumentException("REPLY missing toBlockchainName");
byte[] nameUtf8 = toBlockchainName.getBytes(StandardCharsets.UTF_8);
if (nameUtf8.length == 0 || nameUtf8.length > 255)
throw new IllegalArgumentException("REPLY toBlockchainName utf8 len must be 1..255");
int cap = 1 + nameUtf8.length + 4 + 32 + 2 + msgUtf8.length;
ByteBuffer bb = ByteBuffer.allocate(cap).order(ByteOrder.BIG_ENDIAN);
bb.put((byte) nameUtf8.length);
bb.put(nameUtf8);
bb.putInt(toBlockGlobalNumber);
bb.put(toBlockHash32);
bb.putShort((short) msgUtf8.length);
bb.put(msgUtf8);
return bb.array();
}
// EDIT_REPLY
int cap = (4 + 32) + 2 + msgUtf8.length;
ByteBuffer bb = ByteBuffer.allocate(cap).order(ByteOrder.BIG_ENDIAN);
bb.putInt(toBlockGlobalNumber);
bb.put(toBlockHash32);
bb.putShort((short) msgUtf8.length);
bb.put(msgUtf8);
return bb.array();
}
@Override public String toLogin() { return toLogin; }
@Override public Integer toForkNumber() { return toForkNumber; }
@Override public Integer toBlockGlobalNumber() { return toBlockGlobalNumber; }
@Override public byte[] toBlockHashBytes() { return Arrays.copyOf(toBlockHash32, 32); }
public boolean isEditReply() { return (subType & 0xFFFF) == (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF); }
/* ====================== BodyHasTarget ====================== */
private static String readText(ByteBuffer bb, boolean allowEmpty) {
if (bb.remaining() < 2) throw new IllegalArgumentException("Text length missing");
@Override public String toBchName() { return toBlockchainName; }
@Override public Integer toBlockGlobalNumber() { return toBlockGlobalNumber; }
@Override public byte[] toBlockHashBytes() { return toBlockHash32; }
public boolean isEditReply() {
return (subType & 0xFFFF) == (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF);
}
/* ====================== helpers ====================== */
private static String readStrictUtf8Len16(ByteBuffer bb, String fieldName, boolean allowEmpty) {
int len = Short.toUnsignedInt(bb.getShort());
if (len == 0) { if (allowEmpty) return ""; throw new IllegalArgumentException("Text is empty"); }
if (bb.remaining() < len) throw new IllegalArgumentException("Text payload too short");
byte[] bytes = new byte[len]; bb.get(bytes);
var dec = StandardCharsets.UTF_8.newDecoder().onMalformedInput(CodingErrorAction.REPORT).onUnmappableCharacter(CodingErrorAction.REPORT);
try { String s = dec.decode(ByteBuffer.wrap(bytes)).toString(); if (!allowEmpty && s.isBlank()) throw new IllegalArgumentException("Text is blank"); return s; }
catch (CharacterCodingException e) { throw new IllegalArgumentException("Text invalid UTF-8", e); }
if (len == 0) {
if (allowEmpty) return "";
throw new IllegalArgumentException(fieldName + " is empty");
}
if (bb.remaining() < len) throw new IllegalArgumentException(fieldName + " payload too short (len=" + len + ")");
byte[] bytes = new byte[len];
bb.get(bytes);
var decoder = StandardCharsets.UTF_8.newDecoder()
.onMalformedInput(CodingErrorAction.REPORT)
.onUnmappableCharacter(CodingErrorAction.REPORT);
try {
String s = decoder.decode(ByteBuffer.wrap(bytes)).toString();
if (!allowEmpty && s.isBlank()) throw new IllegalArgumentException(fieldName + " is blank");
return s;
} catch (CharacterCodingException e) {
throw new IllegalArgumentException(fieldName + " is not valid UTF-8", e);
}
}
private static void ensureMin(ByteBuffer bb, int need, String msg) {
if (bb.remaining() < need) throw new IllegalArgumentException(msg + " (need=" + need + ", remaining=" + bb.remaining() + ")");
}
private static void ensureNoTail(ByteBuffer bb, String ctx) {
if (bb.remaining() != 0) throw new IllegalArgumentException("Unexpected tail bytes for " + ctx + ", remaining=" + bb.remaining());
}
}
@@ -11,16 +11,16 @@ import java.util.Arrays;
import java.util.Objects;
/**
* UserParamBody — type=4, ver=1 (в документации: USER_PROFILE).
* UserParamBody — type=4, ver=1 (в заголовке блока).
*
* subType (в заголовке блока):
* 1 = TEXT_TEXT
*
* USER_PROFILE имеет единственную фиксированную линию, поэтому lineCode в body не хранится.
* bodyBytes (BigEndian):
* [4] prevProfileBlockNumber — GLOBAL blockNumber предыдущего USER_PROFILE-блока
* [32] prevProfileBlockHash32 — hash32 предыдущего USER_PROFILE-блока
* [4] profileSequence — порядковый номер изменения профиля (1..N)
* bodyBytes (BigEndian), новый формат:
* [4] lineCode
* [4] prevLineNumber
* [32] prevLineHash32
* [4] thisLineNumber
*
* [2] keyLenBytes (uint16)
* [N] keyUtf8
@@ -35,12 +35,14 @@ public final class UserParamBody implements BodyRecord, BodyHasLine {
public static final int KEY = ((TYPE & 0xFFFF) << 16) | (VER & 0xFFFF);
public final short subType;
public final short version;
public final short subType; // из header
public final short version; // из header
public final int prevProfileBlockNumber;
public final byte[] prevProfileBlockHash32;
public final int profileSequence;
// line
public final int lineCode;
public final int prevLineNumber;
public final byte[] prevLineHash32;
public final int thisLineNumber;
public final String paramKey;
public final String paramValue;
@@ -58,17 +60,21 @@ public final class UserParamBody implements BodyRecord, BodyHasLine {
throw new IllegalArgumentException("Bad UserParam subType: " + (this.subType & 0xFFFF));
}
// prevGlobal(4)+prevHash(32)+seq(4) + keyLen(2)+key(1) + valLen(2)+val(1)
if (bodyBytes.length < 4 + 32 + 4 + 2 + 1 + 2 + 1) {
// минимум: lineCode(4)+line(4+32+4) + keyLen(2)+key(1) + valLen(2)+val(1)
if (bodyBytes.length < 4 + (4 + 32 + 4) + 2 + 1 + 2 + 1) {
throw new IllegalArgumentException("UserParamBody too short");
}
ByteBuffer bb = ByteBuffer.wrap(bodyBytes).order(ByteOrder.BIG_ENDIAN);
this.prevProfileBlockNumber = bb.getInt();
this.prevProfileBlockHash32 = new byte[32];
bb.get(this.prevProfileBlockHash32);
this.profileSequence = bb.getInt();
this.lineCode = bb.getInt();
this.prevLineNumber = bb.getInt();
this.prevLineHash32 = new byte[32];
bb.get(this.prevLineHash32);
this.thisLineNumber = bb.getInt();
int keyLen = Short.toUnsignedInt(bb.getShort());
if (keyLen <= 0) throw new IllegalArgumentException("paramKeyLen is 0");
@@ -93,21 +99,25 @@ public final class UserParamBody implements BodyRecord, BodyHasLine {
if (this.paramValue.isBlank()) throw new IllegalArgumentException("paramValue is blank");
}
public UserParamBody(int prevProfileBlockNumber,
byte[] prevProfileBlockHash32,
int profileSequence,
public UserParamBody(int lineCode,
int prevLineNumber,
byte[] prevLineHash32,
int thisLineNumber,
String paramKey,
String paramValue) {
Objects.requireNonNull(paramKey, "paramKey == null");
Objects.requireNonNull(paramValue, "paramValue == null");
if (lineCode < 0) throw new IllegalArgumentException("lineCode < 0");
this.subType = MsgSubType.USER_PARAM_TEXT_TEXT;
this.version = VER;
this.prevProfileBlockNumber = prevProfileBlockNumber;
this.prevProfileBlockHash32 = (prevProfileBlockHash32 == null ? new byte[32] : Arrays.copyOf(prevProfileBlockHash32, 32));
this.profileSequence = profileSequence;
this.lineCode = lineCode;
this.prevLineNumber = prevLineNumber;
this.prevLineHash32 = (prevLineHash32 == null ? new byte[32] : Arrays.copyOf(prevLineHash32, 32));
this.thisLineNumber = thisLineNumber;
if (paramKey.isBlank()) throw new IllegalArgumentException("paramKey is blank");
if (paramValue.isBlank()) throw new IllegalArgumentException("paramValue is blank");
@@ -118,12 +128,17 @@ public final class UserParamBody implements BodyRecord, BodyHasLine {
@Override
public UserParamBody check() {
if ((subType & 0xFFFF) != (MsgSubType.USER_PARAM_TEXT_TEXT & 0xFFFF)) {
if (lineCode < 0) throw new IllegalArgumentException("lineCode < 0");
if ((subType & 0xFFFF) != (MsgSubType.USER_PARAM_TEXT_TEXT & 0xFFFF))
throw new IllegalArgumentException("Bad UserParam subType: " + (subType & 0xFFFF));
if (prevLineNumber == -1) {
if (!isAllZero32(prevLineHash32)) throw new IllegalArgumentException("prevLineHash32 must be zero when prevLineNumber=-1");
if (thisLineNumber != -1) throw new IllegalArgumentException("thisLineNumber must be -1 when prevLineNumber=-1");
} else {
if (prevLineHash32 == null || prevLineHash32.length != 32) throw new IllegalArgumentException("prevLineHash32 invalid");
}
if (prevProfileBlockNumber < 0) throw new IllegalArgumentException("prevProfileBlockNumber must be >=0");
if (prevProfileBlockHash32 == null || prevProfileBlockHash32.length != 32) throw new IllegalArgumentException("prevProfileBlockHash32 invalid");
if (profileSequence <= 0) throw new IllegalArgumentException("profileSequence must be >=1");
if (paramKey == null || paramKey.isBlank()) throw new IllegalArgumentException("paramKey is blank");
if (paramValue == null || paramValue.isBlank()) throw new IllegalArgumentException("paramValue is blank");
@@ -133,25 +148,30 @@ public final class UserParamBody implements BodyRecord, BodyHasLine {
@Override
public byte[] toBytes() {
check();
byte[] keyUtf8 = paramKey.getBytes(StandardCharsets.UTF_8);
byte[] valUtf8 = paramValue.getBytes(StandardCharsets.UTF_8);
if (keyUtf8.length == 0 || keyUtf8.length > 65535) throw new IllegalArgumentException("paramKey utf8 len must be 1..65535");
if (valUtf8.length == 0 || valUtf8.length > 65535) throw new IllegalArgumentException("paramValue utf8 len must be 1..65535");
int cap = 4 + 32 + 4
int cap = 4 + (4 + 32 + 4)
+ 2 + keyUtf8.length
+ 2 + valUtf8.length;
ByteBuffer bb = ByteBuffer.allocate(cap).order(ByteOrder.BIG_ENDIAN);
bb.putInt(prevProfileBlockNumber);
bb.put(prevProfileBlockHash32);
bb.putInt(profileSequence);
bb.putInt(lineCode);
bb.putInt(prevLineNumber);
bb.put(prevLineHash32 == null ? new byte[32] : Arrays.copyOf(prevLineHash32, 32));
bb.putInt(thisLineNumber);
bb.putShort((short) keyUtf8.length);
bb.put(keyUtf8);
bb.putShort((short) valUtf8.length);
bb.put(valUtf8);
return bb.array();
}
@@ -167,9 +187,15 @@ public final class UserParamBody implements BodyRecord, BodyHasLine {
}
}
/* USER_PROFILE имеет единственную линию, логический lineCode всегда 0. */
@Override public int lineCode() { return 0; }
@Override public int prevLineBlockGlobalNumber() { return prevProfileBlockNumber; }
@Override public byte[] prevLineBlockHash32() { return Arrays.copyOf(prevProfileBlockHash32, 32); }
@Override public int lineSeq() { return profileSequence; }
}
private static boolean isAllZero32(byte[] b) {
if (b == null || b.length != 32) return true;
for (int i = 0; i < 32; i++) if (b[i] != 0) return false;
return true;
}
/* ====================== BodyHasLine ====================== */
@Override public int lineCode() { return lineCode; }
@Override public int prevLineBlockGlobalNumber() { return prevLineNumber; }
@Override public byte[] prevLineBlockHash32() { return prevLineHash32 == null ? null : Arrays.copyOf(prevLineHash32, 32); }
@Override public int lineSeq() { return thisLineNumber; }
}
@@ -1,54 +1,71 @@
package utils.blockchain;
import java.util.Objects;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/** Canonical physical fork name helper: login-NNN, forks are limited to 001..999. */
public final class BlockchainNameUtil {
private static final Pattern SUFFIX = Pattern.compile("^(.*)-(\\d{3})$");
public static final int MIN_FORK_NUMBER = 1;
public static final int MAX_FORK_NUMBER = 999;
/**
* Теперь новое правило:
* blockchainName = login + "-"+ 3 цифры
* Пример: "Dima-001" -> "Dima"
*
* Сколько символов отрезаем с конца blockchainName, чтобы получить login: "-001" = 4
*/
public static final int BLOCKCHAIN_NAME_LOGIN_SUFFIX_LEN = 4;
private BlockchainNameUtil() {}
/**
* Извлечь login из blockchainName: отрезаем последние 4 символа ("-NNN").
* Пример: "Dima-001" -> "Dima"
*/
public static String loginFromBlockchainName(String blockchainName) {
Matcher m = matcher(blockchainName);
return m == null ? null : m.group(1);
}
public static Integer forkNumberFromBlockchainName(String blockchainName) {
Matcher m = matcher(blockchainName);
if (m == null) return null;
int fork = Integer.parseInt(m.group(2));
return fork >= MIN_FORK_NUMBER && fork <= MAX_FORK_NUMBER ? fork : null;
}
public static boolean isBlockchainNameMatchesLogin(String blockchainName, String login) {
if (login == null || login.isBlank()) return false;
String extracted = loginFromBlockchainName(blockchainName);
return extracted != null && Objects.equals(extracted, login.trim());
}
public static String blockchainName(String login, int forkNumber) {
if (login == null || login.isBlank()) throw new IllegalArgumentException("login is blank");
if (forkNumber < MIN_FORK_NUMBER || forkNumber > MAX_FORK_NUMBER) {
throw new IllegalArgumentException("forkNumber must be 1..999");
}
return login.trim() + "-" + String.format("%03d", forkNumber);
}
private static Matcher matcher(String blockchainName) {
if (blockchainName == null) return null;
String s = blockchainName.trim();
if (s.isEmpty()) return null;
Matcher m = SUFFIX.matcher(s);
if (!m.matches() || m.group(1).isBlank()) return null;
try {
int fork = Integer.parseInt(m.group(2));
return fork >= MIN_FORK_NUMBER && fork <= MAX_FORK_NUMBER ? m : null;
} catch (NumberFormatException e) {
return null;
}
if (!hasDashAnd3DigitsSuffix(s)) return null;
return s.substring(0, s.length() - BLOCKCHAIN_NAME_LOGIN_SUFFIX_LEN);
}
}
/**
* Проверка правила:
* - blockchainName должен оканчиваться на "-"+3 цифры
* - blockchainName без суффикса "-NNN" должен равняться login
*
* ВАЖНО:
* - сравнение строгое (case-sensitive)
* - null/blank считаем невалидным
*/
public static boolean isBlockchainNameMatchesLogin(String blockchainName, String login) {
if (blockchainName == null || login == null) return false;
String bn = blockchainName.trim();
String lg = login.trim();
if (bn.isEmpty() || lg.isEmpty()) return false;
if (!hasDashAnd3DigitsSuffix(bn)) return false;
String extracted = bn.substring(0, bn.length() - BLOCKCHAIN_NAME_LOGIN_SUFFIX_LEN);
return Objects.equals(extracted, lg);
}
private static boolean hasDashAnd3DigitsSuffix(String s) {
if (s == null) return false;
int len = s.length();
if (len <= BLOCKCHAIN_NAME_LOGIN_SUFFIX_LEN) return false;
int dashPos = len - 4;
if (s.charAt(dashPos) != '-') return false;
char c1 = s.charAt(len - 3);
char c2 = s.charAt(len - 2);
char c3 = s.charAt(len - 1);
return isDigit(c1) && isDigit(c2) && isDigit(c3);
}
private static boolean isDigit(char c) {
return c >= '0' && c <= '9';
}
}
@@ -0,0 +1,297 @@
package utils.files;
import java.io.IOException;
import java.nio.file.*;
import java.util.Objects;
/**
* ===============================================================
* FileStoreUtil — утилита работы с файлами в папке data/.
*
* Теперь поддерживает:
* - основной файл блокчейна: <blockchainName>.bch
* - временный файл блокчейна: <blockchainName>.tmp_bch
* - sidecar-файл проверки записи: <blockchainName>.write_check
* - marker-файл записи: <blockchainName>.write_pending
*
* Важное:
* - validateSimpleFileName() запрещает path traversal.
* - atomicReplaceBlockchainFile(): пытается сделать ATOMIC_MOVE (если ФС поддерживает),
* иначе делает обычный REPLACE_EXISTING move.
* ===============================================================
*/
public final class FileStoreUtil {
/** Базовая папка для хранения всех файлов (создаётся автоматически). */
public static final String DATA_DIR_NAME = "data";
/** Расширение основного файла блокчейна. */
public static final String BLOCKCHAIN_FILE_EXTENSION = ".bch";
/** Расширение временного файла (старое+новое). */
public static final String BLOCKCHAIN_TMP_EXTENSION = ".tmp_bch";
/** Маркер того, что chain сейчас в процессе полного resync. */
public static final String BLOCKCHAIN_RESYNC_MARKER_EXTENSION = ".resync_pending";
/** Marker того, что обычный AddBlock находится в опасной фазе записи. */
public static final String BLOCKCHAIN_WRITE_PENDING_MARKER_EXTENSION = ".write_pending";
/** Sidecar-файл с blockNumber/blockHash для обычного AddBlock. */
public static final String BLOCKCHAIN_WRITE_CHECK_EXTENSION = ".write_check";
private static final FileStoreUtil INSTANCE = new FileStoreUtil();
private final Path dataDirPath;
private FileStoreUtil() {
this.dataDirPath = Paths.get(DATA_DIR_NAME);
ensureDataDirExists();
}
public static FileStoreUtil getInstance() {
return INSTANCE;
}
/* ===================================================================== */
/* ======================== Базовые операции =========================== */
/* ===================================================================== */
public void newFile(String fileName, byte[] data) {
Objects.requireNonNull(data, "data == null");
Path target = resolveSafe(fileName);
try {
Files.write(target, data,
StandardOpenOption.CREATE,
StandardOpenOption.TRUNCATE_EXISTING,
StandardOpenOption.WRITE);
} catch (IOException e) {
throw new IllegalStateException("Не удалось записать файл: " + target, e);
}
}
public void addDataToFile(String fileName, byte[] data) {
Objects.requireNonNull(data, "data == null");
Path target = resolveSafe(fileName);
try {
Files.write(target, data,
StandardOpenOption.CREATE,
StandardOpenOption.WRITE,
StandardOpenOption.APPEND);
} catch (IOException e) {
throw new IllegalStateException("Не удалось дописать файл: " + target, e);
}
}
public byte[] readAllDataFromFile(String fileName) {
Path target = resolveSafe(fileName);
if (!Files.exists(target)) {
throw new IllegalStateException("Файл не найден: " + target);
}
try {
return Files.readAllBytes(target);
} catch (IOException e) {
throw new IllegalStateException("Не удалось прочитать файл: " + target, e);
}
}
public boolean exists(String fileName) {
Path target = resolveSafe(fileName);
return Files.exists(target);
}
public long size(String fileName) {
Path target = resolveSafe(fileName);
try {
return Files.size(target);
} catch (IOException e) {
throw new IllegalStateException("Не удалось получить размер файла: " + target, e);
}
}
/* ===================================================================== */
/* ===================== Блокчейн-файлы по имени ======================= */
/* ===================================================================== */
/** <blockchainName>.bch */
public String buildBlockchainFileName(String blockchainName) {
validateSimpleFileName(blockchainName);
return blockchainName + BLOCKCHAIN_FILE_EXTENSION;
}
/** <blockchainName>.tmp_bch */
public String buildBlockchainTmpFileName(String blockchainName) {
validateSimpleFileName(blockchainName);
return blockchainName + BLOCKCHAIN_TMP_EXTENSION;
}
public Path resolveBlockchainPath(String blockchainName) {
return resolveSafe(buildBlockchainFileName(blockchainName));
}
public Path resolveBlockchainTmpPath(String blockchainName) {
return resolveSafe(buildBlockchainTmpFileName(blockchainName));
}
public byte[] readBlockchain(String blockchainName) {
return readAllDataFromFile(buildBlockchainFileName(blockchainName));
}
public void writeBlockchainTmp(String blockchainName, byte[] data) {
newFile(buildBlockchainTmpFileName(blockchainName), data);
}
/** <blockchainName>.write_check */
public String buildBlockchainWriteCheckFileName(String blockchainName) {
validateSimpleFileName(blockchainName);
return blockchainName + BLOCKCHAIN_WRITE_CHECK_EXTENSION;
}
public Path resolveBlockchainWriteCheckPath(String blockchainName) {
return resolveSafe(buildBlockchainWriteCheckFileName(blockchainName));
}
public void writeBlockchainWriteCheck(String blockchainName, int blockNumber, String blockHashHex) {
StringBuilder sb = new StringBuilder(128);
sb.append("blockNumber=").append(blockNumber).append('\n');
sb.append("blockHash=").append(blockHashHex == null ? "" : blockHashHex).append('\n');
newFile(buildBlockchainWriteCheckFileName(blockchainName), sb.toString().getBytes(java.nio.charset.StandardCharsets.UTF_8));
}
/** <blockchainName>.write_pending */
public String buildBlockchainWritePendingMarkerFileName(String blockchainName) {
validateSimpleFileName(blockchainName);
return blockchainName + BLOCKCHAIN_WRITE_PENDING_MARKER_EXTENSION;
}
public Path resolveBlockchainWritePendingMarkerPath(String blockchainName) {
return resolveSafe(buildBlockchainWritePendingMarkerFileName(blockchainName));
}
public void writeBlockchainWritePendingMarker(String blockchainName) {
newFile(buildBlockchainWritePendingMarkerFileName(blockchainName), new byte[0]);
}
/** <blockchainName>.resync_pending */
public String buildBlockchainResyncMarkerFileName(String blockchainName) {
validateSimpleFileName(blockchainName);
return blockchainName + BLOCKCHAIN_RESYNC_MARKER_EXTENSION;
}
public Path resolveBlockchainResyncMarkerPath(String blockchainName) {
return resolveSafe(buildBlockchainResyncMarkerFileName(blockchainName));
}
public void writeBlockchainResyncMarker(String blockchainName, String markerContent) {
byte[] data = markerContent == null ? new byte[0] : markerContent.getBytes(java.nio.charset.StandardCharsets.UTF_8);
newFile(buildBlockchainResyncMarkerFileName(blockchainName), data);
}
public void deleteIfExists(Path path) {
if (path == null) {
return;
}
try {
Files.deleteIfExists(path);
} catch (IOException e) {
throw new IllegalStateException("Не удалось удалить файл: " + path, e);
}
}
public void deleteBlockchainFileIfExists(String blockchainName) {
deleteIfExists(resolveBlockchainPath(blockchainName));
}
public void deleteBlockchainTmpFileIfExists(String blockchainName) {
deleteIfExists(resolveBlockchainTmpPath(blockchainName));
}
public void deleteBlockchainWriteCheckIfExists(String blockchainName) {
deleteIfExists(resolveBlockchainWriteCheckPath(blockchainName));
}
public void deleteBlockchainWritePendingMarkerIfExists(String blockchainName) {
deleteIfExists(resolveBlockchainWritePendingMarkerPath(blockchainName));
}
public void deleteBlockchainResyncMarkerIfExists(String blockchainName) {
deleteIfExists(resolveBlockchainResyncMarkerPath(blockchainName));
}
public boolean existsBlockchainResyncMarker(String blockchainName) {
return exists(buildBlockchainResyncMarkerFileName(blockchainName));
}
/**
* Атомарно заменить основной файл блокчейна временным:
* <name>.tmp_bch -> <name>.bch
*
* Стратегия:
* 1) Пытаемся Files.move(..., ATOMIC_MOVE, REPLACE_EXISTING)
* 2) Если ATOMIC_MOVE не поддерживается — делаем move с REPLACE_EXISTING без атомарности
*
* Важный нюанс:
* - атомарность гарантируется только в пределах одной файловой системы.
*/
public void atomicReplaceBlockchainFile(String blockchainName) {
Path tmp = resolveBlockchainTmpPath(blockchainName);
Path main = resolveBlockchainPath(blockchainName);
if (!Files.exists(tmp)) {
throw new IllegalStateException("TMP-файл не найден: " + tmp);
}
try {
// 1) Пытаемся атомарный move
Files.move(tmp, main,
StandardCopyOption.REPLACE_EXISTING,
StandardCopyOption.ATOMIC_MOVE);
} catch (AtomicMoveNotSupportedException e) {
// 2) Если ФС не поддерживает атомарный move — делаем обычный replace
try {
Files.move(tmp, main, StandardCopyOption.REPLACE_EXISTING);
} catch (IOException ex) {
throw new IllegalStateException("Не удалось заменить файл блокчейна (non-atomic): " + main, ex);
}
} catch (IOException e) {
throw new IllegalStateException("Не удалось заменить файл блокчейна (atomic): " + main, e);
}
}
/* ===================================================================== */
/* ============================ Helpers ================================= */
/* ===================================================================== */
private void ensureDataDirExists() {
try {
if (!Files.exists(dataDirPath)) {
Files.createDirectories(dataDirPath);
}
} catch (IOException e) {
throw new IllegalStateException("Не удалось создать директорию хранения: " + dataDirPath, e);
}
}
private Path resolveSafe(String fileName) {
validateSimpleFileName(fileName);
return dataDirPath.resolve(fileName);
}
/**
* Валидация "простого имени":
* - запрещаем слэши, обратные слэши, ".."
* - запрещаем пустоту
*
* Важно: сюда у нас попадает и blockchainName (как часть имени файла),
* поэтому blockchainName должен быть "простым": без путей.
*/
private void validateSimpleFileName(String fileName) {
Objects.requireNonNull(fileName, "fileName == null");
if (fileName.isBlank()) {
throw new IllegalArgumentException("Имя файла не должно быть пустым");
}
if (fileName.contains("/") || fileName.contains("\\") || fileName.contains("..")) {
throw new IllegalArgumentException("Недопустимое имя файла: " + fileName);
}
}
}
@@ -1,74 +0,0 @@
package blockchain;
import org.junit.jupiter.api.Test;
import utils.crypto.Ed25519Util;
import java.nio.charset.StandardCharsets;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
final class Ans104DataItemTest {
@Test
void ed25519RoundTripWithTestAndChannelTags() {
byte[] privateKey = Ed25519Util.generatePrivateKeyFromString("shine-ans104-test-key");
byte[] owner = Ed25519Util.derivePublicKey(privateKey);
byte[] data = "frame-v1-test".getBytes(StandardCharsets.UTF_8);
List<Ans104DataItem.Tag> tags = List.of(
new Ans104DataItem.Tag(ShineProtocolTags.APP_TAG_NAME, ShineProtocolTags.APP_TAG_VALUE),
new Ans104DataItem.Tag(ShineProtocolTags.CHANNEL_TAG_NAME, "books")
);
byte[] message = Ans104DataItem.buildSigningMessage(owner, tags, data);
byte[] signature = Ed25519Util.sign(message, privateKey);
byte[] raw = Ans104DataItem.serializeEd25519(signature, owner, tags, data);
Ans104DataItem parsed = new Ans104DataItem(raw);
assertEquals(2, parsed.signatureType());
assertArrayEquals(owner, parsed.owner32());
assertArrayEquals(data, parsed.data());
assertTrue(parsed.hasTag(ShineProtocolTags.APP_TAG_NAME, ShineProtocolTags.APP_TAG_VALUE));
assertEquals("books", parsed.tagValue(ShineProtocolTags.CHANNEL_TAG_NAME));
assertTrue(parsed.verifySignature());
assertEquals(32, parsed.id32().length);
}
@Test
void mutationBreaksSignature() {
byte[] privateKey = Ed25519Util.generatePrivateKeyFromString("shine-ans104-mutation-key");
byte[] owner = Ed25519Util.derivePublicKey(privateKey);
byte[] data = "original".getBytes(StandardCharsets.UTF_8);
List<Ans104DataItem.Tag> tags = List.of(new Ans104DataItem.Tag(ShineProtocolTags.APP_TAG_NAME, ShineProtocolTags.APP_TAG_VALUE));
byte[] signature = Ed25519Util.sign(Ans104DataItem.buildSigningMessage(owner, tags, data), privateKey);
byte[] raw = Ans104DataItem.serializeEd25519(signature, owner, tags, data);
raw[raw.length - 1] ^= 1;
assertFalse(new Ans104DataItem(raw).verifySignature());
}
@Test
void signingMessageMatchesArbundlesTurboCompatibilityVector() {
byte[] owner = new byte[32];
for (int i = 0; i < owner.length; i++) owner[i] = (byte) i;
byte[] data = "frame-v1-test".getBytes(StandardCharsets.UTF_8);
List<Ans104DataItem.Tag> tags = List.of(
new Ans104DataItem.Tag(ShineProtocolTags.APP_TAG_NAME, ShineProtocolTags.APP_TAG_VALUE),
new Ans104DataItem.Tag(ShineProtocolTags.CHANNEL_TAG_NAME, "books")
);
byte[] actual = Ans104DataItem.buildSigningMessage(owner, tags, data);
byte[] expected = hex("1abe0371d12268b34be32ca5ebf3d3d2189f9d311d9004c142538ca8a4312faa329d1a4873df72dd01b632a2ecce6b87");
assertArrayEquals(expected, actual);
}
private static byte[] hex(String value) {
if ((value.length() & 1) != 0) throw new IllegalArgumentException("odd hex length");
byte[] out = new byte[value.length() / 2];
for (int i = 0; i < out.length; i++) {
int hi = Character.digit(value.charAt(i * 2), 16);
int lo = Character.digit(value.charAt(i * 2 + 1), 16);
if (hi < 0 || lo < 0) throw new IllegalArgumentException("bad hex");
out[i] = (byte) ((hi << 4) | lo);
}
return out;
}
}
@@ -1,68 +0,0 @@
package blockchain;
import blockchain.body.CreateChannelBody;
import org.junit.jupiter.api.Test;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.StandardCharsets;
import static org.junit.jupiter.api.Assertions.*;
final class CreateChannelBodyNameLengthTest {
private static CreateChannelBody newChannel(String name) {
return new CreateChannelBody(
0, 0, new byte[32], 1, name, "",
CreateChannelBody.CHANNEL_TYPE_PUBLIC,
CreateChannelBody.CHANNEL_TYPE_VERSION_DEFAULT
);
}
@Test
void newChannelMustContainAtLeastFourCharacters() {
for (String name : new String[]{"a", "ab", "abc"}) {
CreateChannelBody body = newChannel(name);
assertDoesNotThrow(body::check, "Исторический декодер не должен блокировать: " + name);
assertThrows(IllegalArgumentException.class, body::checkForCreate, name);
assertThrows(IllegalArgumentException.class, body::toBytes, name);
}
}
@Test
void fourToThirtyTwoCharactersAreAccepted() {
for (String name : new String[]{"abcd", "tantra", "X".repeat(32)}) {
CreateChannelBody newBody = newChannel(name);
assertDoesNotThrow(newBody::checkForCreate, name);
CreateChannelBody fromHistory = assertInstanceOf(
CreateChannelBody.class,
BodyRecordParser.parse(CreateChannelBody.TYPE, CreateChannelBody.SUBTYPE,
CreateChannelBody.VER, newBody.toBytes())
);
assertEquals(name, fromHistory.channelName);
}
assertThrows(IllegalArgumentException.class, () -> newChannel("x".repeat(33)).toBytes());
}
@Test
void historicalThreeCharacterBlockStillDecodes() {
// Байт-в-байт существующий формат, без использования сериализатора новых блоков.
byte[] name = "abc".getBytes(StandardCharsets.UTF_8);
ByteBuffer raw = ByteBuffer.allocate(4 + 4 + 32 + 4 + 1 + name.length + 2 + 4)
.order(ByteOrder.BIG_ENDIAN);
raw.putInt(0).putInt(0).put(new byte[32]).putInt(1);
raw.put((byte) name.length).put(name);
raw.putShort((short) 0);
raw.putShort(CreateChannelBody.CHANNEL_TYPE_PUBLIC);
raw.putShort(CreateChannelBody.CHANNEL_TYPE_VERSION_DEFAULT);
CreateChannelBody parsed = assertInstanceOf(
CreateChannelBody.class,
BodyRecordParser.parse(CreateChannelBody.TYPE, CreateChannelBody.SUBTYPE,
CreateChannelBody.VER, raw.array())
);
assertEquals("abc", parsed.channelName);
assertDoesNotThrow(parsed::check);
assertThrows(IllegalArgumentException.class, parsed::checkForCreate);
}
}
@@ -1,100 +0,0 @@
package blockchain;
import blockchain.body.ForkBody;
import org.junit.jupiter.api.Test;
import java.util.Arrays;
import static org.junit.jupiter.api.Assertions.*;
final class ForkBodyTest {
@Test
void roundTripThroughBodyRecordParser() {
byte[] parentKey = filled(32, 0x11);
byte[] forkHash = filled(32, 0x22);
byte[] tipHash = filled(32, 0x33);
ForkBody source = new ForkBody(
0,
77,
filled(32, 0x44),
5,
parentKey,
120,
forkHash,
1_700_000_000_000L,
137,
tipHash,
1_700_100_000_000L,
17,
ForkBody.REASON_CONFIRMED_COMPROMISE_ROLLBACK,
"Удаляю неизвестные записи"
).check();
ForkBody parsed = assertInstanceOf(
ForkBody.class,
BodyRecordParser.parse(ForkBody.TYPE, ForkBody.SUBTYPE, ForkBody.VER, source.toBytes())
);
assertEquals(0, parsed.lineCode);
assertEquals(77, parsed.prevLineNumber);
assertEquals(5, parsed.thisLineNumber);
assertArrayEquals(parentKey, parsed.parentBlockchainKey32);
assertEquals(120, parsed.forkPointBlockNumber);
assertArrayEquals(forkHash, parsed.forkPointBlockHash32);
assertEquals(137, parsed.parentTipBlockNumber);
assertArrayEquals(tipHash, parsed.parentTipBlockHash32);
assertEquals(17, parsed.discardedBlocksCount);
assertEquals(ForkBody.REASON_CONFIRMED_COMPROMISE_ROLLBACK, parsed.reasonCode);
assertEquals("Удаляю неизвестные записи", parsed.comment);
}
@Test
void routineRotationMayDiscardNothing() {
ForkBody body = new ForkBody(
0,
0,
filled(32, 9),
1,
filled(32, 1),
10,
filled(32, 2),
1000,
10,
filled(32, 2),
1000,
0,
ForkBody.REASON_ROUTINE_ROTATION,
""
);
assertDoesNotThrow(body::check);
}
@Test
void rejectedWhenDiscardCountDoesNotMatchForkPointAndTip() {
ForkBody body = new ForkBody(
0,
0,
filled(32, 9),
1,
filled(32, 1),
10,
filled(32, 2),
1000,
12,
filled(32, 3),
2000,
99,
ForkBody.REASON_POSSIBLE_COMPROMISE,
""
);
assertThrows(IllegalArgumentException.class, body::check);
}
private static byte[] filled(int size, int value) {
byte[] out = new byte[size];
Arrays.fill(out, (byte) value);
return out;
}
}
@@ -1,138 +0,0 @@
package blockchain;
import blockchain.body.ConnectionBody;
import blockchain.body.HeaderBody;
import blockchain.body.ReactionBody;
import blockchain.body.StatusActionBody;
import blockchain.body.TextLineBody;
import blockchain.body.TextRatingBody;
import blockchain.body.TextReplyBody;
import org.junit.jupiter.api.Test;
import java.util.Arrays;
import static org.junit.jupiter.api.Assertions.*;
final class TargetLoginFormatTest {
private static final byte[] HASH = hash(7);
private static final byte[] INITIAL_KEY = hash(11);
@Test
void externalTargetRoundTripKeepsHistoricalForkMetadata() {
ReactionBody source = new ReactionBody(MsgSubType.REACTION_LIKE, "alice", 7, 42, HASH);
ReactionBody parsed = new ReactionBody(MsgSubType.REACTION_LIKE, ReactionBody.VER, source.toBytes()).check();
assertEquals("alice", parsed.toLogin());
assertEquals(7, parsed.toForkNumber());
assertEquals(42, parsed.toBlockGlobalNumber());
assertArrayEquals(HASH, parsed.toBlockHashBytes());
assertFalse(new String(source.toBytes()).contains("alice-007"));
}
@Test
void replyIsExternalButEditReplyIsCompactOwnChainTarget() {
TextReplyBody reply = new TextReplyBody(MsgSubType.TEXT_REPLY, "alice", 12, 11, HASH, "reply");
TextReplyBody parsedReply = new TextReplyBody(MsgSubType.TEXT_REPLY, TextReplyBody.VER, reply.toBytes()).check();
assertEquals("alice", parsedReply.toLogin());
assertEquals(12, parsedReply.toForkNumber());
TextReplyBody edit = new TextReplyBody(MsgSubType.TEXT_EDIT_REPLY, null, null, 11, HASH, "");
TextReplyBody parsedEdit = new TextReplyBody(MsgSubType.TEXT_EDIT_REPLY, TextReplyBody.VER, edit.toBytes()).check();
assertNull(parsedEdit.toLogin());
assertNull(parsedEdit.toForkNumber());
assertEquals(11, parsedEdit.toBlockGlobalNumber());
assertArrayEquals(HASH, parsedEdit.toBlockHashBytes());
assertTrue(edit.toBytes().length < reply.toBytes().length);
}
@Test
void editPostIsCompactAndConnectionUsesRealExternalTarget() {
TextLineBody editPost = new TextLineBody(
0, -1, new byte[32], -1,
MsgSubType.TEXT_EDIT_POST,
null, null, 5, HASH, "edited"
);
TextLineBody parsedEditPost = new TextLineBody(MsgSubType.TEXT_EDIT_POST, TextLineBody.VER, editPost.toBytes()).check();
assertNull(parsedEditPost.toLogin());
assertNull(parsedEditPost.toForkNumber());
assertEquals(5, parsedEditPost.toBlockGlobalNumber());
ConnectionBody connection = new ConnectionBody(
0, HASH, 1,
MsgSubType.CONNECTION_FOLLOW,
"alice", 3, 0, HASH
);
ConnectionBody parsedConnection = new ConnectionBody(MsgSubType.CONNECTION_FOLLOW, ConnectionBody.VER, connection.toBytes()).check();
assertEquals("alice", parsedConnection.toLogin());
assertEquals(3, parsedConnection.toForkNumber());
assertEquals(0, parsedConnection.toBlockGlobalNumber());
assertArrayEquals(HASH, parsedConnection.toBlockHashBytes());
}
@Test
void ratingAndStatusCarryHistoricalForkNumber() {
TextRatingBody rating = new TextRatingBody("alice", 9, 70, HASH, "5");
TextRatingBody parsedRating = new TextRatingBody(MsgSubType.TEXT_RATING, TextRatingBody.VER, rating.toBytes()).check();
assertEquals(9, parsedRating.toForkNumber());
StatusActionBody status = new StatusActionBody(MsgSubType.STATUS_STARTED, "alice", 9, 77, HASH, "");
StatusActionBody parsedStatus = new StatusActionBody(MsgSubType.STATUS_STARTED, StatusActionBody.VER, status.toBytes()).check();
assertEquals("alice", parsedStatus.toLogin());
assertEquals(9, parsedStatus.toForkNumber());
assertEquals(77, parsedStatus.toBlockGlobalNumber());
}
@Test
void forkZeroIsReservedButStillDecodableAsHistoricalUnknown() {
ReactionBody source = new ReactionBody(MsgSubType.REACTION_LIKE, "alice", 0, 42, HASH);
ReactionBody parsed = new ReactionBody(MsgSubType.REACTION_LIKE, ReactionBody.VER, source.toBytes()).check();
assertEquals(0, parsed.toForkNumber());
}
@Test
void headerCarriesInitialBlockchainKey() {
HeaderBody source = new HeaderBody("alice", INITIAL_KEY);
HeaderBody parsed = new HeaderBody(HeaderBody.SUBTYPE_COMPAT, HeaderBody.VER, source.toBytes()).check();
assertEquals("alice", parsed.login);
assertArrayEquals(INITIAL_KEY, parsed.initialBlockchainKey32);
}
@Test
void namespacedHeaderRoundTripAcceptsPaidAndFreeUsers() {
for (String login : new String[]{"alice@free", "AlexSmith@shine", "a_B@free", "abcdefghijklmnopqrstuvwxy@free"}) {
HeaderBody source = new HeaderBody(login, INITIAL_KEY);
HeaderBody parsed = new HeaderBody(HeaderBody.SUBTYPE_COMPAT, HeaderBody.VER, source.toBytes()).check();
assertEquals(login, parsed.login);
assertArrayEquals(INITIAL_KEY, parsed.initialBlockchainKey32);
}
}
@Test
void namespacedHeaderRejectsMalformedOrOversizedLogin() {
for (String login : new String[]{"alice@", "@shine", "alice@@free", "alice@FREE", "alice.free@shine", "abcdefghijklmnopqrstuvwxyz@free"}) {
assertThrows(IllegalArgumentException.class, () -> new HeaderBody(login, INITIAL_KEY), login);
}
}
@Test
void signedReferencesPreserveArbitraryLoginCaseWithoutServerSideCaseEnforcement() {
// Адресация не зависит от регистра, но блок сохраняет выбранные автором байты.
for (String login : new String[]{"AlexSmith@shine", "alexsmith@shine"}) {
TextReplyBody reply = new TextReplyBody(MsgSubType.TEXT_REPLY, login, 1, 42, HASH, "тест");
assertEquals(login, new TextReplyBody(MsgSubType.TEXT_REPLY, TextReplyBody.VER, reply.toBytes()).check().toLogin());
ReactionBody like = new ReactionBody(MsgSubType.REACTION_LIKE, login, 1, 42, HASH);
assertEquals(login, new ReactionBody(MsgSubType.REACTION_LIKE, ReactionBody.VER, like.toBytes()).check().toLogin());
ConnectionBody follow = new ConnectionBody(0, HASH, 1, MsgSubType.CONNECTION_FOLLOW, login, 1, 0, HASH);
assertEquals(login, new ConnectionBody(MsgSubType.CONNECTION_FOLLOW, ConnectionBody.VER, follow.toBytes()).check().toLogin());
}
}
private static byte[] hash(int seed) {
byte[] out = new byte[32];
Arrays.fill(out, (byte) seed);
return out;
}
}
@@ -66,20 +66,19 @@ public final class AppConfig {
/** Вернёт строку или пустую строку, если параметр не найден. */
public String getStringOrEmpty(String name) {
String value = getParam(name);
String value = properties.getProperty(name);
return value == null ? "" : value.trim();
}
/** Целочисленный параметр с тем же приоритетом: system property -> env -> properties. */
/** Можно добавить методы для удобства */
public int getInt(String name, int defaultValue) {
String v = getParam(name);
return v == null || v.isBlank() ? defaultValue : Integer.parseInt(v.trim());
String v = properties.getProperty(name);
return v == null ? defaultValue : Integer.parseInt(v);
}
/** Boolean-параметр с тем же приоритетом: system property -> env -> properties. */
public boolean getBoolean(String name, boolean defaultValue) {
String v = getParam(name);
return v == null || v.isBlank() ? defaultValue : Boolean.parseBoolean(v.trim());
String v = properties.getProperty(name);
return v == null ? defaultValue : Boolean.parseBoolean(v);
}
private static String toEnvName(String name) {
@@ -17,11 +17,8 @@ public final class ShineSignatureConstants {
/** Подписываемые данные пользовательских настроек: prefix + login + type + key + time_ms + value_text + value_num */
public static final String USER_SETTINGS_PREFIX = "SHiNe/UserSettings:";
/** Подписанный watermark чтения канала: prefix + login + owner_bch_name + channel_name + time_ms + read_count */
public static final String CHANNEL_READ_STATE_PREFIX = "SHiNe/ChannelReadState:";
/** TAG в HeaderBody (genesis). ASCII "SHiNE". */
public static final String BLOCKCHAIN_HEADER_TAG = "SHiNE";
/** TAG в HeaderBody (genesis). ASCII "SHiNe". */
public static final String BLOCKCHAIN_HEADER_TAG = "SHiNe";
/** DOMAIN для preimage при расчёте hash32 блока. ASCII "SHiNe". */
public static final String BLOCK_HASH_DOMAIN = "SHiNe";
@@ -1,7 +1,7 @@
# utils.crypto
Пакет отвечает за криптографию — подписи и хэши блоков.
Используется при создании и проверке криптографических сущностей SHiNE; пользовательские blockchain-файлы `.bch` больше не используются.
Используется при создании и проверке целостности `.bch`-блоков.
---
@@ -17,31 +17,26 @@ import java.util.List;
public final class DatabaseInitializer {
public static final String DB_SCHEMA_VERSION_TABLE = "db_schema_version";
public static final String DB_FORMAT_MARKER_TABLE = "shine_database_metadata";
public static final String DB_FORMAT_MARKER = "SHiNE_DB_V2";
public static final int DB_FORMAT_VERSION = 2;
public static final int SCHEMA_VERSION_1 = 1;
public static final int SCHEMA_VERSION_31 = 31;
public static final int SCHEMA_VERSION_32 = 32;
public static final int SCHEMA_VERSION_33 = 33;
public static final int SCHEMA_VERSION_34 = 34;
public static final int SCHEMA_VERSION_35 = 35;
public static final int SCHEMA_VERSION_36 = 36;
public static final int SCHEMA_VERSION_37 = 37;
public static final int SCHEMA_VERSION_38 = 38;
public static final int SCHEMA_VERSION_39 = 39;
public static final int SCHEMA_VERSION_40 = 40;
public static final int SCHEMA_VERSION_2 = 2;
public static final int SCHEMA_VERSION_3 = 3;
public static final int SCHEMA_VERSION_4 = 4;
public static final int SCHEMA_VERSION_5 = 5;
public static final int SCHEMA_VERSION_6 = 6;
public static final int SCHEMA_VERSION_7 = 7;
public static final int SCHEMA_VERSION_8 = 8;
public static final int SCHEMA_VERSION_9 = 9;
public static final int SCHEMA_VERSION_10 = 10;
public static final String POSTGRES_SCHEMA_RESOURCE = "postgres/schema_v1.sql";
public static final String POSTGRES_MIGRATION_V31_RESOURCE = "postgres/migration_v31.sql";
public static final String POSTGRES_MIGRATION_V32_RESOURCE = "postgres/migration_v32.sql";
public static final String POSTGRES_MIGRATION_V33_RESOURCE = "postgres/migration_v33.sql";
public static final String POSTGRES_MIGRATION_V34_RESOURCE = "postgres/migration_v34.sql";
public static final String POSTGRES_MIGRATION_V35_RESOURCE = "postgres/migration_v35.sql";
public static final String POSTGRES_MIGRATION_V36_RESOURCE = "postgres/migration_v36.sql";
public static final String POSTGRES_MIGRATION_V37_RESOURCE = "postgres/migration_v37.sql";
public static final String POSTGRES_MIGRATION_V38_RESOURCE = "postgres/migration_v38.sql";
public static final String POSTGRES_MIGRATION_V39_RESOURCE = "postgres/migration_v39.sql";
public static final String POSTGRES_MIGRATION_V40_RESOURCE = "postgres/migration_v40.sql";
public static final String POSTGRES_MIGRATION_V2_RESOURCE = "postgres/migration_v2.sql";
public static final String POSTGRES_MIGRATION_V3_RESOURCE = "postgres/migration_v3.sql";
public static final String POSTGRES_MIGRATION_V4_RESOURCE = "postgres/migration_v4.sql";
public static final String POSTGRES_MIGRATION_V5_RESOURCE = "postgres/migration_v5.sql";
public static final String POSTGRES_MIGRATION_V6_RESOURCE = "postgres/migration_v6.sql";
public static final String POSTGRES_MIGRATION_V7_RESOURCE = "postgres/migration_v7.sql";
public static final String POSTGRES_MIGRATION_V8_RESOURCE = "postgres/migration_v8.sql";
public static final String POSTGRES_MIGRATION_V9_RESOURCE = "postgres/migration_v9.sql";
public static final String POSTGRES_MIGRATION_V10_RESOURCE = "postgres/migration_v10.sql";
private DatabaseInitializer() {}
@@ -52,7 +47,6 @@ public final class DatabaseInitializer {
public static final short TEXT_RATING = 30;
public static final short TEXT_REPOST = 50;
public static final short TEXT_CHANNEL_META = 90;
public static final short TEXT_CHANNEL_DELETE = 92;
public static final short TEXT_ENTRYPOINT = 100;
public static final short TEXT_EXERCISE = 110;
public static final short TEXT_SERVICE = 120;
@@ -64,17 +58,12 @@ public final class DatabaseInitializer {
public static final short CONNECTION_CLOSE_FRIEND = 10;
public static final short CONNECTION_UNCLOSE_FRIEND = 11;
public static final short CONNECTION_FRIEND = 14;
public static final short CONNECTION_UNFRIEND = 15;
public static final short CONNECTION_CONTACT = 20;
public static final short CONNECTION_UNCONTACT = 21;
// FOLLOW на публичный канал используется; user-to-user FOLLOW legacy. DO NOT REMOVE.
public static final short CONNECTION_FOLLOW = 30;
public static final short CONNECTION_UNFOLLOW = 31;
// Родственные связи пока не используются в UI. DO NOT REMOVE.
public static final short CONNECTION_SPOUSE = 40;
public static final short CONNECTION_UNSPOUSE = 41;
@@ -87,20 +76,15 @@ public final class DatabaseInitializer {
public static final short CONNECTION_SIBLING = 54;
public static final short CONNECTION_UNSIBLING = 55;
// Legacy 60/61: новый UI не использует. DO NOT REMOVE.
public static final short CONNECTION_KNOWN_PERSON = 60;
public static final short CONNECTION_UNKNOWN_PERSON = 61;
public static final short CONNECTION_SHINE_CONFIRMED = 70;
public static final short CONNECTION_SHINE_UNCONFIRMED = 71;
// Пока не используется в UI. DO NOT REMOVE.
public static final short CONNECTION_SHINE_SEEN = 74;
public static final short CONNECTION_SHINE_UNSEEN = 75;
public static final short CONNECTION_OFFICIAL_ACCOUNT_CONFIRMED = 80;
public static final short CONNECTION_OFFICIAL_ACCOUNT_UNCONFIRMED = 81;
public static void ensurePostgresSchemaInitialized(String jdbcUrl,
String user,
String password) throws SQLException {
@@ -111,73 +95,46 @@ public final class DatabaseInitializer {
}
try (Connection conn = openConnection(jdbcUrl, user, password)) {
boolean markerTableExists = postgresTableExists(conn, DB_FORMAT_MARKER_TABLE);
boolean schemaVersionTableExists = postgresTableExists(conn, DB_SCHEMA_VERSION_TABLE);
if (!markerTableExists) {
if (schemaVersionTableExists || currentSchemaHasBaseTables(conn)) {
throw new SQLException(
"Legacy/non-v2 SHiNE PostgreSQL database detected. "
+ "Stage 2 requires an empty database initialized as " + DB_FORMAT_MARKER
+ "; automatic migration from the old database is intentionally disabled.");
}
if (!postgresSchemaVersionTableExists(conn)) {
runSqlScript(conn, POSTGRES_SCHEMA_RESOURCE);
markerTableExists = postgresTableExists(conn, DB_FORMAT_MARKER_TABLE);
schemaVersionTableExists = postgresTableExists(conn, DB_SCHEMA_VERSION_TABLE);
return;
}
if (!markerTableExists || !schemaVersionTableExists) {
throw new SQLException(
"Invalid SHiNE PostgreSQL database: required v2 metadata/schema tables are missing.");
}
validateDatabaseFormatV2(conn);
int currentVersion = readCurrentSchemaVersion(conn);
if (currentVersion == 30) {
runSqlScript(conn, POSTGRES_MIGRATION_V31_RESOURCE);
currentVersion = readCurrentSchemaVersion(conn);
if (currentVersion < SCHEMA_VERSION_2) {
runSqlScript(conn, POSTGRES_MIGRATION_V2_RESOURCE);
currentVersion = SCHEMA_VERSION_2;
}
if (currentVersion == SCHEMA_VERSION_31) {
runSqlScript(conn, POSTGRES_MIGRATION_V32_RESOURCE);
currentVersion = readCurrentSchemaVersion(conn);
if (currentVersion < SCHEMA_VERSION_3) {
runSqlScript(conn, POSTGRES_MIGRATION_V3_RESOURCE);
currentVersion = SCHEMA_VERSION_3;
}
if (currentVersion == SCHEMA_VERSION_32) {
runSqlScript(conn, POSTGRES_MIGRATION_V33_RESOURCE);
currentVersion = readCurrentSchemaVersion(conn);
if (currentVersion < SCHEMA_VERSION_4) {
runSqlScript(conn, POSTGRES_MIGRATION_V4_RESOURCE);
currentVersion = SCHEMA_VERSION_4;
}
if (currentVersion == SCHEMA_VERSION_33) {
runSqlScript(conn, POSTGRES_MIGRATION_V34_RESOURCE);
currentVersion = readCurrentSchemaVersion(conn);
if (currentVersion < SCHEMA_VERSION_5) {
runSqlScript(conn, POSTGRES_MIGRATION_V5_RESOURCE);
currentVersion = SCHEMA_VERSION_5;
}
if (currentVersion == SCHEMA_VERSION_34) {
runSqlScript(conn, POSTGRES_MIGRATION_V35_RESOURCE);
currentVersion = readCurrentSchemaVersion(conn);
if (currentVersion < SCHEMA_VERSION_6) {
runSqlScript(conn, POSTGRES_MIGRATION_V6_RESOURCE);
currentVersion = SCHEMA_VERSION_6;
}
if (currentVersion == SCHEMA_VERSION_35) {
runSqlScript(conn, POSTGRES_MIGRATION_V36_RESOURCE);
currentVersion = readCurrentSchemaVersion(conn);
if (currentVersion < SCHEMA_VERSION_7) {
runSqlScript(conn, POSTGRES_MIGRATION_V7_RESOURCE);
currentVersion = SCHEMA_VERSION_7;
}
if (currentVersion == SCHEMA_VERSION_36) {
runSqlScript(conn, POSTGRES_MIGRATION_V37_RESOURCE);
currentVersion = readCurrentSchemaVersion(conn);
if (currentVersion < SCHEMA_VERSION_8) {
runSqlScript(conn, POSTGRES_MIGRATION_V8_RESOURCE);
currentVersion = SCHEMA_VERSION_8;
}
if (currentVersion == SCHEMA_VERSION_37) {
runSqlScript(conn, POSTGRES_MIGRATION_V38_RESOURCE);
currentVersion = readCurrentSchemaVersion(conn);
if (currentVersion < SCHEMA_VERSION_9) {
runSqlScript(conn, POSTGRES_MIGRATION_V9_RESOURCE);
currentVersion = SCHEMA_VERSION_9;
}
if (currentVersion == SCHEMA_VERSION_38) {
runSqlScript(conn, POSTGRES_MIGRATION_V39_RESOURCE);
currentVersion = readCurrentSchemaVersion(conn);
if (currentVersion < SCHEMA_VERSION_10) {
runSqlScript(conn, POSTGRES_MIGRATION_V10_RESOURCE);
}
if (currentVersion == SCHEMA_VERSION_39) {
runSqlScript(conn, POSTGRES_MIGRATION_V40_RESOURCE);
currentVersion = readCurrentSchemaVersion(conn);
}
if (currentVersion != SCHEMA_VERSION_40) {
throw new SQLException(
"Unsupported SHiNE DB v2 schema version: expected 40, found " + currentVersion);
}
normalizeBlockchainStateKeysToBase64(conn);
}
}
@@ -188,60 +145,23 @@ public final class DatabaseInitializer {
return DriverManager.getConnection(jdbcUrl, user, password == null ? "" : password);
}
private static boolean postgresTableExists(Connection conn, String tableName) throws SQLException {
private static boolean postgresSchemaVersionTableExists(Connection conn) throws SQLException {
String sql = """
SELECT EXISTS (
SELECT 1
FROM information_schema.tables
WHERE table_schema = current_schema()
AND table_name = ?
AND table_type = 'BASE TABLE'
)
""";
try (var ps = conn.prepareStatement(sql)) {
ps.setString(1, tableName);
ps.setString(1, DB_SCHEMA_VERSION_TABLE);
try (ResultSet rs = ps.executeQuery()) {
return rs.next() && rs.getBoolean(1);
}
}
}
private static boolean currentSchemaHasBaseTables(Connection conn) throws SQLException {
String sql = """
SELECT EXISTS (
SELECT 1
FROM information_schema.tables
WHERE table_schema = current_schema()
AND table_type = 'BASE TABLE'
)
""";
try (Statement st = conn.createStatement(); ResultSet rs = st.executeQuery(sql)) {
return rs.next() && rs.getBoolean(1);
}
}
private static void validateDatabaseFormatV2(Connection conn) throws SQLException {
String sql = """
SELECT database_format, database_generation
FROM shine_database_metadata
WHERE id = 1
""";
try (Statement st = conn.createStatement(); ResultSet rs = st.executeQuery(sql)) {
if (!rs.next()) {
throw new SQLException(
"Invalid SHiNE PostgreSQL database: SHiNE_DB_V2 metadata row is missing.");
}
String format = rs.getString("database_format");
int generation = rs.getInt("database_generation");
if (!DB_FORMAT_MARKER.equals(format) || generation != DB_FORMAT_VERSION) {
throw new SQLException(
"Unsupported SHiNE PostgreSQL database format: expected " + DB_FORMAT_MARKER
+ " generation " + DB_FORMAT_VERSION
+ ", found format=" + format + ", generation=" + generation);
}
}
}
private static int readCurrentSchemaVersion(Connection conn) throws SQLException {
String sql = """
SELECT schema_version
@@ -257,38 +177,6 @@ public final class DatabaseInitializer {
}
}
/**
* blockchain_state — runtime-проекция: публичный blockchain key хранится
* строго как Base64(32). Ранний импорт free-регистраций ошибочно сохранял
* Base58, поэтому нормализация выполняется идемпотентно при старте.
*/
private static void normalizeBlockchainStateKeysToBase64(Connection conn) throws SQLException {
record StateKey(String login, int forkNumber, String key) {}
List<StateKey> entries = new ArrayList<>();
try (Statement st = conn.createStatement();
ResultSet rs = st.executeQuery("SELECT login, fork_number, blockchain_key FROM blockchain_state_store")) {
while (rs.next()) {
entries.add(new StateKey(rs.getString("login"), rs.getInt("fork_number"), rs.getString("blockchain_key")));
}
}
try (var update = conn.prepareStatement("""
UPDATE blockchain_state_store
SET blockchain_key = ?
WHERE login = ? AND fork_number = ?
""")) {
for (StateKey entry : entries) {
String normalized = KeyEncodingUtil.normalizeKeyToBase64_32(entry.key());
if (normalized == null || normalized.equals(entry.key())) continue;
update.setString(1, normalized);
update.setString(2, entry.login());
update.setInt(3, entry.forkNumber());
update.addBatch();
}
update.executeBatch();
}
}
private static void runSqlScript(Connection conn, String resourcePath) throws SQLException {
String sqlScript = loadClasspathResource(resourcePath);
List<String> statements = splitSqlStatements(sqlScript);
@@ -1,7 +1,6 @@
package shine.db;
import shine.db.connection.DbProvider;
import shine.db.dao.DmDialogStateDAO;
import java.sql.Connection;
import java.sql.SQLException;
@@ -16,7 +15,6 @@ public final class DbController implements DbProvider {
private static volatile DbController instance;
private final PostgresDbController delegate;
private volatile boolean dmDialogStateBootstrapped;
private DbController() {
this.delegate = PostgresDbController.getInstance();
@@ -26,9 +24,7 @@ public final class DbController implements DbProvider {
if (instance == null) {
synchronized (DbController.class) {
if (instance == null) {
DbController created = new DbController();
instance = created;
created.bootstrapDmDialogStateIfNeeded();
instance = new DbController();
}
}
}
@@ -44,18 +40,4 @@ public final class DbController implements DbProvider {
public void close() {
delegate.close();
}
private void bootstrapDmDialogStateIfNeeded() {
if (dmDialogStateBootstrapped) return;
synchronized (this) {
if (dmDialogStateBootstrapped) return;
try (Connection connection = delegate.getConnection()) {
DmDialogStateDAO.getInstance().bootstrapIfEmpty(connection);
dmDialogStateBootstrapped = true;
} catch (SQLException e) {
instance = null;
throw new RuntimeException("DM dialog state bootstrap failed", e);
}
}
}
}
@@ -23,46 +23,6 @@ public final class KeyEncodingUtil {
private KeyEncodingUtil() {}
public static String encodeBase58(byte[] input) {
if (input == null || input.length == 0) {
return "";
}
byte[] copy = java.util.Arrays.copyOf(input, input.length);
int zeros = 0;
while (zeros < copy.length && copy[zeros] == 0) {
zeros++;
}
byte[] encoded = new byte[copy.length * 2];
int outputStart = encoded.length;
int inputStart = zeros;
while (inputStart < copy.length) {
int remainder = divmod58(copy, inputStart);
if (copy[inputStart] == 0) {
inputStart++;
}
encoded[--outputStart] = (byte) BASE58_ALPHABET.charAt(remainder);
}
while (outputStart < encoded.length && encoded[outputStart] == (byte) BASE58_ALPHABET.charAt(0)) {
outputStart++;
}
while (--zeros >= 0) {
encoded[--outputStart] = (byte) BASE58_ALPHABET.charAt(0);
}
return new String(encoded, outputStart, encoded.length - outputStart, java.nio.charset.StandardCharsets.US_ASCII);
}
public static String base58KeyToBase64_32(String rawKey) {
if (rawKey == null) {
return null;
}
String value = rawKey.trim();
if (value.isEmpty()) {
return value;
}
byte[] decoded = tryDecodeBase58_32(value);
return decoded == null ? value : Base64.getEncoder().encodeToString(decoded);
}
public static String normalizeKeyToBase64_32(String rawKey) {
if (rawKey == null) {
return null;
@@ -142,17 +102,6 @@ public final class KeyEncodingUtil {
return result;
}
private static int divmod58(byte[] number, int startAt) {
int remainder = 0;
for (int i = startAt; i < number.length; i++) {
int digit256 = number[i] & 0xFF;
int temp = remainder * 256 + digit256;
number[i] = (byte) (temp / 58);
remainder = temp % 58;
}
return remainder;
}
private static int divmod256(byte[] number58, int startAt) {
int remainder = 0;
for (int i = startAt; i < number58.length; i++) {
@@ -4,7 +4,7 @@ package shine.db;
* MsgSubType — единое место для ВСЕХ subType сообщений (msg_sub_type).
*
* ВАЖНО:
* - Значения должны совпадать с body-классами (TextLineBody/TextReplyBody/TextRatingBody/ReactionBody/ConnectionBody/UserParamBody/HeaderBody).
* - Значения должны совпадать с body-классами (TextBody/ReactionBody/ConnectionBody/UserParamBody/HeaderBody).
* - После релиза менять числа нельзя (иначе ломается совместимость данных).
*/
public final class MsgSubType {
@@ -38,7 +38,6 @@ public final class MsgSubType {
/** CHANNEL_META — скрытый технический снимок профиля канала. */
public static final short TEXT_CHANNEL_META = 90;
public static final short TEXT_CHANNEL_DELETE = 92;
/** ENTRYPOINT — входная страница канала (line-based). */
public static final short TEXT_ENTRYPOINT = 100;
@@ -59,10 +58,10 @@ public final class MsgSubType {
/* ===================== CONNECTION (msg_type=3) ===================== */
/**
* Совпадает с ConnectionBody:
* SET: CLOSE_FRIEND=10, FRIEND=14, CONTACT=20, FOLLOW=30, SPOUSE=40, PARENT=50, CHILD=52, SIBLING=54,
* KNOWN_PERSON(legacy)=60, SHINE_CONFIRMED=70, SHINE_SEEN=74, OFFICIAL_ACCOUNT_CONFIRMED=80
* UNSET: UNCLOSE_FRIEND=11, UNFRIEND=15, UNCONTACT=21, UNFOLLOW=31, UNSPOUSE=41, UNPARENT=51, UNCHILD=53, UNSIBLING=55,
* UNKNOWN_PERSON(legacy)=61, SHINE_UNCONFIRMED=71, SHINE_UNSEEN=75, OFFICIAL_ACCOUNT_UNCONFIRMED=81
* SET: CLOSE_FRIEND=10, CONTACT=20, FOLLOW=30, SPOUSE=40, PARENT=50, CHILD=52, SIBLING=54,
* KNOWN_PERSON=60, SHINE_CONFIRMED=70, SHINE_SEEN=74
* UNSET: UNCLOSE_FRIEND=11, UNCONTACT=21, UNFOLLOW=31, UNSPOUSE=41, UNPARENT=51, UNCHILD=53, UNSIBLING=55,
* UNKNOWN_PERSON=61, SHINE_UNCONFIRMED=71, SHINE_UNSEEN=75
*/
/** Добавить в близкие друзья (close friend). */
@@ -71,26 +70,18 @@ public final class MsgSubType {
/** Удалить из близких друзей (close friend). */
public static final short CONNECTION_UNCLOSE_FRIEND = 11;
/** Добавить в друзья. */
public static final short CONNECTION_FRIEND = 14;
/** Удалить из друзей. */
public static final short CONNECTION_UNFRIEND = 15;
/** Добавить в контакты. */
public static final short CONNECTION_CONTACT = 20;
/** Удалить из контактов. */
public static final short CONNECTION_UNCONTACT = 21;
// FOLLOW на публичный канал используется. Старый FOLLOW пользователя считается legacy. DO NOT REMOVE.
/** Подписаться (follow). */
public static final short CONNECTION_FOLLOW = 30;
/** Отписаться (unfollow). */
public static final short CONNECTION_UNFOLLOW = 31;
// Родственные связи пока не используются в UI. Сохраняем коды. DO NOT REMOVE.
/** Добавить связь "жена/муж". */
public static final short CONNECTION_SPOUSE = 40;
@@ -115,8 +106,10 @@ public final class MsgSubType {
/** Удалить связь "брат/сестра". */
public static final short CONNECTION_UNSIBLING = 55;
// Legacy 60/61: принимаем старые данные, но новый UI их не использует. DO NOT REMOVE.
/** Просто знаю этого человека. */
public static final short CONNECTION_KNOWN_PERSON = 60;
/** Не знаю этого человека. */
public static final short CONNECTION_UNKNOWN_PERSON = 61;
/** Точно уверен, что сияющий. */
@@ -125,19 +118,12 @@ public final class MsgSubType {
/** Не подтверждаю, что сияющий. */
public static final short CONNECTION_SHINE_UNCONFIRMED = 71;
// Пока не используется в UI. Сохраняем для совместимости. DO NOT REMOVE.
/** Мало знаком, но видел сияющим. */
public static final short CONNECTION_SHINE_SEEN = 74;
/** Не отмечаю, что видел сияющим. */
public static final short CONNECTION_SHINE_UNSEEN = 75;
/** Подтверждение официального аккаунта человека. */
public static final short CONNECTION_OFFICIAL_ACCOUNT_CONFIRMED = 80;
/** Снятие подтверждения официального аккаунта человека. */
public static final short CONNECTION_OFFICIAL_ACCOUNT_UNCONFIRMED = 81;
/* ===================== USER_PARAM (msg_type=4) ===================== */
/** Параметр профиля key/value (обе строки). */
@@ -28,7 +28,7 @@ public final class PostgresDbController {
try {
DatabaseInitializer.ensurePostgresSchemaInitialized(jdbcUrl, dbUser, dbPassword);
} catch (SQLException e) {
throw new RuntimeException("PostgreSQL database compatibility/init failed: " + e.getMessage(), e);
throw new RuntimeException("PostgreSQL schema auto-init failed", e);
}
this.delegate = new DriverManagerDbProvider(jdbcUrl, dbUser, dbPassword, connection -> {
@@ -4,7 +4,7 @@ import java.util.Locale;
import java.util.regex.Pattern;
public final class ChannelNameRules {
private static final int MIN_DISPLAY_NAME_LENGTH = 4;
private static final int MIN_DISPLAY_NAME_LENGTH = 3;
private static final int MAX_DISPLAY_NAME_LENGTH = 32;
private static final Pattern DISPLAY_ALLOWED_PATTERN =
Pattern.compile("^[A-Za-z0-9_-]+$");
@@ -26,7 +26,7 @@ public final class ChannelNameRules {
int length = normalized.codePointCount(0, normalized.length());
if (length < MIN_DISPLAY_NAME_LENGTH || length > MAX_DISPLAY_NAME_LENGTH) {
throw new IllegalArgumentException("channelName length must be 4..32");
throw new IllegalArgumentException("channelName length must be 3..32");
}
if (!DISPLAY_ALLOWED_PATTERN.matcher(normalized).matches()) {
@@ -269,57 +269,6 @@ public final class ActiveSessionsDAO {
}
}
/**
* Удаляет все сессии пользователя, кроме указанной текущей, и возвращает их sessionId.
* Вариант с Connection используется внутри транзакции запуска key rotation.
*/
public List<String> deleteOtherSessions(Connection c, String login, String keepSessionId) throws SQLException {
List<String> sessionIds = new ArrayList<>();
String selectSql = """
SELECT session_id
FROM active_sessions
WHERE LOWER(login) = LOWER(?)
AND session_id <> ?
""";
try (PreparedStatement ps = c.prepareStatement(selectSql)) {
ps.setString(1, login);
ps.setString(2, keepSessionId == null ? "" : keepSessionId);
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) sessionIds.add(rs.getString(1));
}
}
if (sessionIds.isEmpty()) return sessionIds;
String deleteSql = """
DELETE FROM active_sessions
WHERE LOWER(login) = LOWER(?)
AND session_id <> ?
""";
try (PreparedStatement ps = c.prepareStatement(deleteSql)) {
ps.setString(1, login);
ps.setString(2, keepSessionId == null ? "" : keepSessionId);
ps.executeUpdate();
}
return sessionIds;
}
public List<String> deleteOtherSessions(String login, String keepSessionId) throws SQLException {
try (Connection c = db.getConnection()) {
boolean oldAutoCommit = c.getAutoCommit();
c.setAutoCommit(false);
try {
List<String> ids = deleteOtherSessions(c, login, keepSessionId);
c.commit();
return ids;
} catch (SQLException e) {
c.rollback();
throw e;
} finally {
c.setAutoCommit(oldAutoCommit);
}
}
}
// -------------------- MAPPER --------------------
private ActiveSessionEntry mapRow(ResultSet rs) throws SQLException {
@@ -1,183 +0,0 @@
package shine.db.dao;
import shine.db.DbController;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
/** Persistent discovery/import queue for individual ANS-104 SHiNE DataItems found through Arweave. */
public final class ArweaveBlockImportDAO {
public static final String STATUS_PENDING = "PENDING";
public static final String STATUS_REJECTED = "REJECTED";
public record QueueItem(byte[] dataItemId, long blockHeight,
byte[] rawDataItem, String status, String lastError,
long firstSeenAtMs, long updatedAtMs,
String parsedLogin, Integer parsedForkNumber, Integer parsedBlockNumber, byte[] parsedBlockHash,
boolean metadataValidated) {}
private static volatile ArweaveBlockImportDAO instance;
private final DbController db = DbController.getInstance();
private ArweaveBlockImportDAO() {}
public static ArweaveBlockImportDAO getInstance() {
if (instance == null) {
synchronized (ArweaveBlockImportDAO.class) {
if (instance == null) instance = new ArweaveBlockImportDAO();
}
}
return instance;
}
public long getLastBlockHeight() throws SQLException {
try (Connection c = db.getConnection();
PreparedStatement ps = c.prepareStatement("SELECT last_block_height FROM arweave_block_sync_state WHERE id=1");
ResultSet rs = ps.executeQuery()) {
return rs.next() ? rs.getLong(1) : 0L;
}
}
public void setLastBlockHeight(long height, long nowMs) throws SQLException {
String sql = """
INSERT INTO arweave_block_sync_state(id,last_block_height,updated_at_ms)
VALUES(1,?,?)
ON CONFLICT(id) DO UPDATE SET last_block_height=EXCLUDED.last_block_height, updated_at_ms=EXCLUDED.updated_at_ms
""";
try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(sql)) {
ps.setLong(1, Math.max(0L, height));
ps.setLong(2, nowMs);
ps.executeUpdate();
}
}
/** Insert once. Existing IDs (including REJECTED) are deliberately not re-enqueued. */
public boolean enqueueIfMissing(byte[] dataItemId, String rootTxId, long blockHeight, byte[] rawDataItem, long nowMs)
throws SQLException {
String sql = """
INSERT INTO arweave_block_import_queue(
data_item_id,root_tx_id,block_height,raw_data_item,status,last_error,first_seen_at_ms,updated_at_ms
) VALUES(?,?,?,?,?, '',?,?)
ON CONFLICT(data_item_id) DO NOTHING
""";
try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(sql)) {
ps.setBytes(1, dataItemId);
ps.setString(2, rootTxId == null ? "" : rootTxId.trim());
ps.setLong(3, blockHeight);
ps.setBytes(4, rawDataItem);
ps.setString(5, STATUS_PENDING);
ps.setLong(6, nowMs);
ps.setLong(7, nowMs);
return ps.executeUpdate() > 0;
}
}
public boolean exists(byte[] dataItemId) throws SQLException {
try (Connection c = db.getConnection();
PreparedStatement ps = c.prepareStatement("SELECT 1 FROM arweave_block_import_queue WHERE data_item_id=? LIMIT 1")) {
ps.setBytes(1, dataItemId);
try (ResultSet rs = ps.executeQuery()) { return rs.next(); }
}
}
public List<QueueItem> listPending(int limit) throws SQLException {
int safeLimit = Math.max(1, Math.min(limit, 100_000));
String sql = """
SELECT data_item_id,block_height,raw_data_item,status,last_error,first_seen_at_ms,updated_at_ms,
parsed_login,parsed_fork_number,parsed_block_number,parsed_block_hash,metadata_validated
FROM arweave_block_import_queue
WHERE status=?
ORDER BY block_height ASC, first_seen_at_ms ASC
LIMIT ?
""";
List<QueueItem> out = new ArrayList<>();
try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, STATUS_PENDING);
ps.setInt(2, safeLimit);
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
out.add(new QueueItem(
rs.getBytes("data_item_id"), rs.getLong("block_height"),
rs.getBytes("raw_data_item"), rs.getString("status"), rs.getString("last_error"),
rs.getLong("first_seen_at_ms"), rs.getLong("updated_at_ms"),
rs.getString("parsed_login"), (Integer) rs.getObject("parsed_fork_number"),
(Integer) rs.getObject("parsed_block_number"), rs.getBytes("parsed_block_hash"),
rs.getBoolean("metadata_validated")));
}
}
}
return out;
}
/** Persist cryptographically validated parse metadata used to order canonical replay. */
public void markMetadataValidated(byte[] id, String login, int forkNumber, int blockNumber, byte[] blockHash, long nowMs)
throws SQLException {
String sql = """
UPDATE arweave_block_import_queue
SET parsed_login=?,parsed_fork_number=?,parsed_block_number=?,parsed_block_hash=?,metadata_validated=TRUE,
last_error='',updated_at_ms=?
WHERE data_item_id=? AND status=?
""";
try (Connection c=db.getConnection(); PreparedStatement ps=c.prepareStatement(sql)) {
ps.setString(1, login); ps.setInt(2, forkNumber); ps.setInt(3, blockNumber); ps.setBytes(4, blockHash);
ps.setLong(5, nowMs); ps.setBytes(6, id); ps.setString(7, STATUS_PENDING); ps.executeUpdate();
}
}
/** Pending items with verified signatures/owner metadata, in deterministic logical replay order. */
public List<QueueItem> listPendingValidated(int limit) throws SQLException {
int safeLimit=Math.max(1,Math.min(limit,100_000));
String sql="""
SELECT data_item_id,block_height,raw_data_item,status,last_error,first_seen_at_ms,updated_at_ms,
parsed_login,parsed_fork_number,parsed_block_number,parsed_block_hash,metadata_validated
FROM arweave_block_import_queue
WHERE status=? AND metadata_validated=TRUE
ORDER BY LOWER(parsed_login) ASC, parsed_block_number ASC, parsed_fork_number ASC, first_seen_at_ms ASC
LIMIT ?
""";
List<QueueItem> out=new ArrayList<>();
try(Connection c=db.getConnection();PreparedStatement ps=c.prepareStatement(sql)){
ps.setString(1,STATUS_PENDING);ps.setInt(2,safeLimit);
try(ResultSet rs=ps.executeQuery()){while(rs.next())out.add(new QueueItem(
rs.getBytes("data_item_id"),rs.getLong("block_height"),rs.getBytes("raw_data_item"),
rs.getString("status"),rs.getString("last_error"),rs.getLong("first_seen_at_ms"),rs.getLong("updated_at_ms"),
rs.getString("parsed_login"),(Integer)rs.getObject("parsed_fork_number"),(Integer)rs.getObject("parsed_block_number"),
rs.getBytes("parsed_block_hash"),rs.getBoolean("metadata_validated")));
}
}
return out;
}
public void setPendingError(byte[] id, String error, long nowMs) throws SQLException {
updateStatus(id, STATUS_PENDING, error, nowMs);
}
public void reject(byte[] id, String error, long nowMs) throws SQLException {
updateStatus(id, STATUS_REJECTED, error, nowMs);
}
public void delete(byte[] id) throws SQLException {
try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(
"DELETE FROM arweave_block_import_queue WHERE data_item_id=?")) {
ps.setBytes(1, id);
ps.executeUpdate();
}
}
private void updateStatus(byte[] id, String status, String error, long nowMs) throws SQLException {
try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(
"UPDATE arweave_block_import_queue SET status=?,last_error=?,updated_at_ms=? WHERE data_item_id=?")) {
ps.setString(1, status);
ps.setString(2, trimError(error));
ps.setLong(3, nowMs);
ps.setBytes(4, id);
ps.executeUpdate();
}
}
private static String trimError(String s) {
String v = s == null ? "" : s.replace('\n',' ').replace('\r',' ').trim();
return v.length() <= 500 ? v : v.substring(0,500);
}
}
@@ -1,27 +0,0 @@
package shine.db.dao;
import shine.db.DbController;
import java.sql.*;
/** Persistent ancestry/cache for segmented logical blockchains. */
public final class BlockchainForkSegmentsDAO {
private static volatile BlockchainForkSegmentsDAO instance;
private final DbController db=DbController.getInstance();
private BlockchainForkSegmentsDAO(){}
public static BlockchainForkSegmentsDAO getInstance(){ if(instance==null) synchronized(BlockchainForkSegmentsDAO.class){ if(instance==null) instance=new BlockchainForkSegmentsDAO(); } return instance; }
public record Segment(String login,int forkNumber,Integer parentForkNumber,int forkPointBlockNumber,byte[] forkPointBlockHash,int firstPhysicalBlockNumber,long createdAtMs){}
public Segment get(Connection c,String login,int fork)throws SQLException{
try(PreparedStatement ps=c.prepareStatement("SELECT login,fork_number,parent_fork_number,fork_point_block_number,fork_point_block_hash,first_physical_block_number,created_at_ms FROM blockchain_fork_segments WHERE LOWER(login)=LOWER(?) AND fork_number=?")){
ps.setString(1,login);ps.setInt(2,fork);try(ResultSet rs=ps.executeQuery()){if(!rs.next())return null; Object parent=rs.getObject(3); return new Segment(rs.getString(1),rs.getInt(2),parent==null?null:rs.getInt(3),rs.getInt(4),rs.getBytes(5),rs.getInt(6),rs.getLong(7));}
}
}
public Segment get(String login,int fork)throws SQLException{try(Connection c=db.getConnection()){return get(c,login,fork);}}
public void upsert(Connection c,Segment s)throws SQLException{
try(PreparedStatement ps=c.prepareStatement("""
INSERT INTO blockchain_fork_segments(login,fork_number,parent_fork_number,fork_point_block_number,fork_point_block_hash,first_physical_block_number,created_at_ms)
VALUES(?,?,?,?,?,?,?) ON CONFLICT(login,fork_number) DO UPDATE SET parent_fork_number=EXCLUDED.parent_fork_number,fork_point_block_number=EXCLUDED.fork_point_block_number,fork_point_block_hash=EXCLUDED.fork_point_block_hash,first_physical_block_number=EXCLUDED.first_physical_block_number
""")){ps.setString(1,s.login());ps.setInt(2,s.forkNumber());if(s.parentForkNumber()==null)ps.setNull(3,Types.INTEGER);else ps.setInt(3,s.parentForkNumber());ps.setInt(4,s.forkPointBlockNumber());if(s.forkPointBlockHash()==null)ps.setNull(5,Types.BINARY);else ps.setBytes(5,s.forkPointBlockHash());ps.setInt(6,s.firstPhysicalBlockNumber());ps.setLong(7,s.createdAtMs());ps.executeUpdate();}
}
}
@@ -1,298 +1,394 @@
package shine.db.dao;
import shine.db.DatabaseInitializer;
import shine.db.DbController;
import java.sql.*;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* Atomic cleanup of one physical fork before deterministic replay.
* Physical fork identity is (login,fork_number). Incoming logical state is never rebound/deleted.
* BlockchainResyncCleanupDAO — подготовительный "жёсткий reset" одной blockchain-цепочки
* перед её полной повторной загрузкой от сервера-партнёра.
*
* Что делает этот DAO:
* 1) в ОДНОЙ SQL-транзакции сначала аккуратно уменьшает чужие агрегаты,
* которые были увеличены блоками удаляемой цепочки:
* - likes_count
* - replies_count
* 2) затем удаляет все локальные записи самой цепочки и её производные состояния.
*
* Почему это вынесено в отдельный DAO-метод, а не в триггеры DELETE:
* - нам нужен один понятный "блок операции", который можно вызвать из resync-flow;
* - эта схема проще и прозрачнее, чем много обратных триггеров по разным таблицам;
* - если любой шаг не удался, делаем rollback и БД остаётся в исходном состоянии;
* - файловые действия (.bch / .tmp_bch) сознательно НЕ входят в эту транзакцию:
* SQL-транзакция и файловая система не коммитятся атомарно вместе;
* поэтому БД-чистка делается здесь, а файловая чистка будет следующим шагом
* отдельным recovery/resync-слоем после успешного commit.
*
* Важный смысл текущей реализации:
* - мы НЕ трогаем current users слой (`solana_user_pda_current`) и НЕ трогаем DM-таблицы;
* - мы очищаем только блокчейн пользователя и derived-state, который строится из неё;
* - висячие cross-chain ссылки в чужих blocks допускаются как нормальное поведение системы.
*/
public final class BlockchainResyncCleanupDAO {
private static final int BLOCKCHAIN_LOGIN_SUFFIX_LEN = 4; // "-001"
private static volatile BlockchainResyncCleanupDAO instance;
private final DbController db=DbController.getInstance();
private BlockchainResyncCleanupDAO(){}
public static BlockchainResyncCleanupDAO getInstance(){ if(instance==null) synchronized(BlockchainResyncCleanupDAO.class){if(instance==null)instance=new BlockchainResyncCleanupDAO();} return instance; }
public CleanupResult cleanupBlockchainForFullResync(String blockchainName) throws SQLException {
ChainRef ref=chainRef(blockchainName);
try(Connection c=db.getConnection()){
boolean ac=c.getAutoCommit(); c.setAutoCommit(false);
try{
// Targets liked by this actor must survive long enough to recount after actor rows are removed.
try(Statement st=c.createStatement()){
st.execute("CREATE TEMP TABLE IF NOT EXISTS shine_cleanup_targets(to_login TEXT,to_block_number INTEGER,to_block_hash BYTEA,PRIMARY KEY(to_login,to_block_number,to_block_hash)) ON COMMIT DROP");
st.execute("TRUNCATE shine_cleanup_targets");
st.execute("CREATE TEMP TABLE IF NOT EXISTS shine_cleanup_channels(owner_bch_name TEXT,root_number INTEGER,root_hash BYTEA,PRIMARY KEY(owner_bch_name,root_number,root_hash)) ON COMMIT DROP");
st.execute("TRUNCATE shine_cleanup_channels");
st.execute("CREATE TEMP TABLE IF NOT EXISTS shine_cleanup_users(login TEXT PRIMARY KEY) ON COMMIT DROP");
st.execute("TRUNCATE shine_cleanup_users");
}
try(PreparedStatement ps=c.prepareStatement("""
INSERT INTO shine_cleanup_targets(to_login,to_block_number,to_block_hash)
SELECT DISTINCT to_login,to_block_number,to_block_hash FROM reactions_state
WHERE LOWER(from_login)=LOWER(?) AND reaction_type=1 AND last_sub_type=1
ON CONFLICT DO NOTHING
""")){ ps.setString(1,ref.login()); ps.executeUpdate(); }
private final DbController db = DbController.getInstance();
try(PreparedStatement ps=c.prepareStatement("""
INSERT INTO shine_cleanup_users(login)
SELECT DISTINCT to_login FROM connections_state
WHERE LOWER(login)=LOWER(?) AND to_login IS NOT NULL AND btrim(to_login)<>''
ON CONFLICT DO NOTHING
""")){ps.setString(1,ref.login());ps.executeUpdate();}
private BlockchainResyncCleanupDAO() {}
try(PreparedStatement ps=c.prepareStatement("""
INSERT INTO shine_cleanup_channels(owner_bch_name,root_number,root_hash)
SELECT DISTINCT cn.owner_bch_name,cn.channel_root_block_number,cn.channel_root_block_hash
FROM connections_state cs JOIN channel_names_state cn
ON LOWER(cn.owner_login)=LOWER(cs.to_login) AND cn.channel_root_block_number=cs.to_block_number AND cn.channel_root_block_hash=cs.to_block_hash
WHERE LOWER(cs.login)=LOWER(?) AND cs.rel_type=30
ON CONFLICT DO NOTHING
""")){ps.setString(1,ref.login());ps.executeUpdate();}
// Followers of channels owned by this login must be refreshed after those channel projections are removed.
try(PreparedStatement ps=c.prepareStatement("""
INSERT INTO shine_cleanup_users(login)
SELECT DISTINCT cs.login
FROM connections_state cs
JOIN channel_names_state cn
ON LOWER(cn.owner_login)=LOWER(?)
AND LOWER(cs.to_login)=LOWER(cn.owner_login)
AND cs.to_block_number=cn.channel_root_block_number
AND cs.to_block_hash=cn.channel_root_block_hash
WHERE cs.rel_type=30
ON CONFLICT DO NOTHING
""")){ps.setString(1,ref.login());ps.executeUpdate();}
int deletedReactions=delete(c,"DELETE FROM reactions_state WHERE LOWER(from_login)=LOWER(?)",ref.login());
recountAffectedLikes(c);
int deletedConnections=delete(c,"DELETE FROM connections_state WHERE LOWER(login)=LOWER(?)",ref.login());
refreshAffectedChannelStats(c);
int deletedUsersParams=delete(c,"DELETE FROM users_params WHERE LOWER(login)=LOWER(?)",ref.login());
try(PreparedStatement ps=c.prepareStatement("SELECT shine_refresh_user_profile(?)")){ps.setString(1,ref.login());ps.execute();}
try(PreparedStatement ps=c.prepareStatement("SELECT shine_refresh_related_user_stats(?)")){ps.setString(1,ref.login());ps.execute();}
// Channel/chat projections are owned by login; replay recreates them. Incoming social stats are intentionally untouched.
delete(c,"DELETE FROM channel_stats_state WHERE LOWER(owner_login)=LOWER(?)",ref.login());
int deletedChannelNames=delete(c,"DELETE FROM channel_names_state WHERE LOWER(owner_login)=LOWER(?)",ref.login());
refreshAffectedUserStats(c);
int deletedChat200=delete(c,"DELETE FROM chat200_state WHERE LOWER(owner_login)=LOWER(?)",ref.login());
int deletedChatMembers=delete(c,"DELETE FROM chat200_members_state WHERE owner_bch_name LIKE ?",ref.login()+"-%");
try(PreparedStatement ps=c.prepareStatement("SELECT shine_refresh_user_stats(?)")){ps.setString(1,ref.login());ps.execute();}
int deletedBlocks;
try(PreparedStatement ps=c.prepareStatement("DELETE FROM blocks_store WHERE LOWER(login)=LOWER(?) AND fork_number=?")){
ps.setString(1,ref.login()); ps.setInt(2,ref.fork()); deletedBlocks=ps.executeUpdate();
}
int deletedState;
try(PreparedStatement ps=c.prepareStatement("DELETE FROM blockchain_state_store WHERE LOWER(login)=LOWER(?) AND fork_number=?")){
ps.setString(1,ref.login()); ps.setInt(2,ref.fork()); deletedState=ps.executeUpdate();
}
c.commit();
return new CleanupResult(ref.login(),deletedReactions,deletedConnections,deletedUsersParams,deletedChannelNames,deletedChat200,deletedChatMembers,deletedBlocks,deletedState);
}catch(Exception e){ try{c.rollback();}catch(Exception ignored){} if(e instanceof SQLException x)throw x; throw new SQLException("Stage2 fork cleanup failed: "+blockchainName,e); }
finally{try{c.setAutoCommit(ac);}catch(Exception ignored){}}
}
}
/** Clears all materialized state and raw local forks for one login before canonical replay.
* Raw canonical bytes must already be persisted in rebuild staging.
*
* This operation is deliberately idempotent. Before deleting the actor's projections we
* remember every foreign user/channel/message aggregate touched by them, then repair those
* aggregates after the rows/blocks have been removed. Canonical replay can therefore start
* from a clean baseline without double-counting replies, likes or subscriptions.
*/
public void cleanupLoginForCanonicalReplay(String login) throws SQLException {
if(login==null||login.isBlank())throw new IllegalArgumentException("login is blank");
try(Connection c=db.getConnection()){boolean ac=c.getAutoCommit();c.setAutoCommit(false);try{
try(Statement st=c.createStatement()){
st.execute("CREATE TEMP TABLE IF NOT EXISTS shine_cleanup_targets(to_login TEXT,to_block_number INTEGER,to_block_hash BYTEA,PRIMARY KEY(to_login,to_block_number,to_block_hash)) ON COMMIT DROP");
st.execute("TRUNCATE shine_cleanup_targets");
st.execute("CREATE TEMP TABLE IF NOT EXISTS shine_cleanup_reply_targets(to_login TEXT,to_block_number INTEGER,to_block_hash BYTEA,PRIMARY KEY(to_login,to_block_number,to_block_hash)) ON COMMIT DROP");
st.execute("TRUNCATE shine_cleanup_reply_targets");
st.execute("CREATE TEMP TABLE IF NOT EXISTS shine_cleanup_channels(owner_bch_name TEXT,root_number INTEGER,root_hash BYTEA,PRIMARY KEY(owner_bch_name,root_number,root_hash)) ON COMMIT DROP");
st.execute("TRUNCATE shine_cleanup_channels");
st.execute("CREATE TEMP TABLE IF NOT EXISTS shine_cleanup_users(login TEXT PRIMARY KEY) ON COMMIT DROP");
st.execute("TRUNCATE shine_cleanup_users");
public static BlockchainResyncCleanupDAO getInstance() {
if (instance == null) {
synchronized (BlockchainResyncCleanupDAO.class) {
if (instance == null) instance = new BlockchainResyncCleanupDAO();
}
// Existing LIKE state produced by this actor.
try(PreparedStatement ps=c.prepareStatement("INSERT INTO shine_cleanup_targets SELECT DISTINCT to_login,to_block_number,to_block_hash FROM reactions_state WHERE LOWER(from_login)=LOWER(?) AND reaction_type=1 AND last_sub_type=1 ON CONFLICT DO NOTHING")){ps.setString(1,login);ps.executeUpdate();}
// Existing REPLY blocks produced by this actor. Their counters must be recomputed
// after deleting the old canonical blocks and before replay inserts the new canonical set.
try(PreparedStatement ps=c.prepareStatement("""
INSERT INTO shine_cleanup_reply_targets(to_login,to_block_number,to_block_hash)
SELECT DISTINCT to_login,to_block_number,to_block_hash
FROM blocks_store
WHERE LOWER(login)=LOWER(?) AND msg_type=1 AND msg_sub_type=20
AND to_login IS NOT NULL AND to_block_number IS NOT NULL AND to_block_hash IS NOT NULL
ON CONFLICT DO NOTHING
""")){ps.setString(1,login);ps.executeUpdate();}
// Users whose social counters may change when this actor's connection projection disappears.
try(PreparedStatement ps=c.prepareStatement("""
INSERT INTO shine_cleanup_users(login)
SELECT DISTINCT to_login FROM connections_state
WHERE LOWER(login)=LOWER(?) AND to_login IS NOT NULL AND btrim(to_login)<>''
ON CONFLICT DO NOTHING
""")){ps.setString(1,login);ps.executeUpdate();}
try(PreparedStatement ps=c.prepareStatement("INSERT INTO shine_cleanup_users(login) VALUES(?) ON CONFLICT DO NOTHING")){ps.setString(1,login);ps.executeUpdate();}
// Foreign channels followed/unfollowed by this actor.
try(PreparedStatement ps=c.prepareStatement("""
INSERT INTO shine_cleanup_channels(owner_bch_name,root_number,root_hash)
SELECT DISTINCT cn.owner_bch_name,cn.channel_root_block_number,cn.channel_root_block_hash
FROM connections_state cs JOIN channel_names_state cn
ON LOWER(cn.owner_login)=LOWER(cs.to_login)
AND cn.channel_root_block_number=cs.to_block_number
AND cn.channel_root_block_hash=cs.to_block_hash
WHERE LOWER(cs.login)=LOWER(?) AND cs.rel_type=30
ON CONFLICT DO NOTHING
""")){ps.setString(1,login);ps.executeUpdate();}
// Followers of channels owned by this login are also affected while channel projections
// disappear and are recreated by replay.
try(PreparedStatement ps=c.prepareStatement("""
INSERT INTO shine_cleanup_users(login)
SELECT DISTINCT cs.login
FROM connections_state cs
JOIN channel_names_state cn
ON LOWER(cn.owner_login)=LOWER(?)
AND LOWER(cs.to_login)=LOWER(cn.owner_login)
AND cs.to_block_number=cn.channel_root_block_number
AND cs.to_block_hash=cn.channel_root_block_hash
WHERE cs.rel_type=30
ON CONFLICT DO NOTHING
""")){ps.setString(1,login);ps.executeUpdate();}
delete(c,"DELETE FROM reactions_state WHERE LOWER(from_login)=LOWER(?)",login);
recountAffectedLikes(c);
delete(c,"DELETE FROM connections_state WHERE LOWER(login)=LOWER(?)",login);
refreshAffectedChannelStats(c);
delete(c,"DELETE FROM users_params WHERE LOWER(login)=LOWER(?)",login);
delete(c,"DELETE FROM channel_stats_state WHERE LOWER(owner_login)=LOWER(?)",login);
delete(c,"DELETE FROM channel_names_state WHERE LOWER(owner_login)=LOWER(?)",login);
// Notifications are projections of source blockchain blocks. Canonical replay recreates
// only the notifications that still exist on the selected branch.
delete(c,"DELETE FROM user_notifications_state WHERE LOWER(source_login)=LOWER(?)",login);
// Chat200 is legacy/unused and is intentionally not maintained by segmented-fork replay.
delete(c,"DELETE FROM chat200_state WHERE LOWER(owner_login)=LOWER(?)",login);
delete(c,"DELETE FROM chat200_members_state WHERE owner_bch_name LIKE ?",login+"-%");
delete(c,"DELETE FROM blocks_store WHERE LOWER(login)=LOWER(?)",login);
delete(c,"DELETE FROM blockchain_state_store WHERE LOWER(login)=LOWER(?)",login);
// With the old reply blocks gone, establish the exact baseline produced by all other
// actors. Replay will then add this actor's canonical replies exactly once.
recountAffectedReplies(c);
try(PreparedStatement ps=c.prepareStatement("SELECT shine_refresh_user_profile(?)")){ps.setString(1,login);ps.execute();}
try(PreparedStatement ps=c.prepareStatement("SELECT shine_refresh_related_user_stats(?)")){ps.setString(1,login);ps.execute();}
refreshAffectedUserStats(c);
c.commit();
}catch(Exception e){c.rollback();if(e instanceof SQLException x)throw x;throw new SQLException("canonical replay cleanup failed",e);}finally{c.setAutoCommit(ac);}}
}
return instance;
}
/**
* Repairs server-owned projections after canonical replay. It is safe to call repeatedly.
* Signed channel read watermarks are preserved; only server-owned unread values are recomputed.
* Полностью очищает одну blockchain-цепочку и локальные derived-state, собранные из неё.
*
* Порядок внутри транзакции намеренно такой:
* 1. Сначала уменьшаем чужие likes_count для тех целей, где финальное состояние
* реакции этой цепочки было LIKE.
* 2. Сначала уменьшаем чужие replies_count для reply-блоков этой цепочки.
* 3. После этого удаляем локальные derived-state самой цепочки.
* 4. В конце удаляем blocks и blockchain_state.
*
* Это правильно потому, что агрегаты (`message_stats`) должны видеть исходные blocks
* и reactions_state на момент пересчёта. Если удалить blocks раньше, мы потеряем
* источник правды для корректного уменьшения счётчиков.
*
* Метод идемпотентен по смыслу:
* - если часть данных уже удалена раньше, повторный вызов просто удалит "0 строк";
* - если blockchain_state уже отсутствует, login берём из blockchainName.
*
* Отдельно важно:
* - здесь НЕТ удаления .bch/.tmp_bch;
* - здесь НЕТ повторной загрузки цепочки;
* - это только атомарная SQL-очистка БД, на которую потом будет опираться resync-flow.
*/
public void finalizeCanonicalReplay(String login) throws SQLException {
if(login==null||login.isBlank())throw new IllegalArgumentException("login is blank");
try(Connection c=db.getConnection()){boolean ac=c.getAutoCommit();c.setAutoCommit(false);try{
// Remove view references to discarded messages of this user. Valid canonical targets survive.
try(PreparedStatement ps=c.prepareStatement("""
DELETE FROM message_views_state mv
WHERE LOWER(mv.to_login)=LOWER(?)
AND NOT EXISTS (
SELECT 1 FROM blocks_store b
WHERE LOWER(b.login)=LOWER(mv.to_login)
AND b.block_number=mv.to_block_number AND b.block_hash=mv.to_block_hash
)
""")){ps.setString(1,login);ps.executeUpdate();}
public CleanupResult cleanupBlockchainForFullResync(String blockchainName) throws SQLException {
if (blockchainName == null || blockchainName.isBlank()) {
throw new IllegalArgumentException("blockchainName is blank");
}
// Recompute all message aggregates whose target belongs to this user. This also fixes
// external reactions/replies that intentionally survive this user's rebuild.
try(PreparedStatement ps=c.prepareStatement("""
INSERT INTO message_stats(to_login,to_block_number,to_block_hash,likes_count,primary_likes_count,shining_likes_count,replies_count)
SELECT t.login,t.block_number,t.block_hash,
(SELECT COUNT(*)::INTEGER FROM reactions_state r WHERE r.reaction_type=1 AND r.last_sub_type=1 AND LOWER(r.to_login)=LOWER(t.login) AND r.to_block_number=t.block_number AND r.to_block_hash=t.block_hash),
(SELECT COUNT(*)::INTEGER FROM reactions_state r WHERE r.reaction_type=1 AND r.last_sub_type=1 AND LOWER(r.to_login)=LOWER(t.login) AND r.to_block_number=t.block_number AND r.to_block_hash=t.block_hash AND shine_is_primary(r.from_login)),
(SELECT COUNT(*)::INTEGER FROM reactions_state r WHERE r.reaction_type=1 AND r.last_sub_type=1 AND LOWER(r.to_login)=LOWER(t.login) AND r.to_block_number=t.block_number AND r.to_block_hash=t.block_hash AND shine_is_primary(r.from_login) AND shine_is_shining(r.from_login)),
(SELECT COUNT(*)::INTEGER FROM blocks_store rb WHERE rb.msg_type=1 AND rb.msg_sub_type=20 AND LOWER(rb.to_login)=LOWER(t.login) AND rb.to_block_number=t.block_number AND rb.to_block_hash=t.block_hash)
FROM blocks_store t
WHERE LOWER(t.login)=LOWER(?)
AND (
EXISTS(SELECT 1 FROM message_stats oldms WHERE LOWER(oldms.to_login)=LOWER(t.login) AND oldms.to_block_number=t.block_number AND oldms.to_block_hash=t.block_hash)
OR EXISTS(SELECT 1 FROM reactions_state r WHERE LOWER(r.to_login)=LOWER(t.login) AND r.to_block_number=t.block_number AND r.to_block_hash=t.block_hash)
OR EXISTS(SELECT 1 FROM blocks_store rb WHERE rb.msg_type=1 AND rb.msg_sub_type=20 AND LOWER(rb.to_login)=LOWER(t.login) AND rb.to_block_number=t.block_number AND rb.to_block_hash=t.block_hash)
)
ON CONFLICT(to_login,to_block_number,to_block_hash) DO UPDATE SET
likes_count=EXCLUDED.likes_count,
primary_likes_count=EXCLUDED.primary_likes_count,
shining_likes_count=EXCLUDED.shining_likes_count,
replies_count=EXCLUDED.replies_count
""")){ps.setString(1,login);ps.executeUpdate();}
try(PreparedStatement ps=c.prepareStatement("""
DELETE FROM message_stats ms
WHERE LOWER(ms.to_login)=LOWER(?)
AND NOT EXISTS (SELECT 1 FROM blocks_store b WHERE LOWER(b.login)=LOWER(ms.to_login) AND b.block_number=ms.to_block_number AND b.block_hash=ms.to_block_hash)
""")){ps.setString(1,login);ps.executeUpdate();}
try (Connection c = db.getConnection()) {
boolean oldAutoCommit = c.getAutoCommit();
c.setAutoCommit(false);
try {
String login = resolveLoginForCleanup(c, blockchainName);
// Recalculate social/channel aggregates from the final canonical projections.
try(PreparedStatement ps=c.prepareStatement("SELECT shine_refresh_user_stats(?)")){ps.setString(1,login);ps.execute();}
try(PreparedStatement ps=c.prepareStatement("SELECT shine_refresh_related_user_stats(?)")){ps.setString(1,login);ps.execute();}
try(PreparedStatement ps=c.prepareStatement("""
SELECT shine_refresh_channel_follow_stats(owner_bch_name,channel_root_block_number,channel_root_block_hash)
FROM channel_names_state WHERE LOWER(owner_login)=LOWER(?) AND channel_type_code=1
""")){ps.setString(1,login);ps.execute();}
int likesAdjusted = decreaseForeignLikesCount(c, blockchainName);
int repliesAdjusted = decreaseForeignRepliesCount(c, blockchainName);
ChannelReadStateDAO.getInstance().recalculateUnreadForOwnedChannels(c,login,System.currentTimeMillis());
c.commit();
}catch(Exception e){c.rollback();if(e instanceof SQLException x)throw x;throw new SQLException("canonical replay finalize failed",e);}finally{c.setAutoCommit(ac);}}
int deletedMessageStats = deleteMessageStatsForOwnTargets(c, blockchainName);
int deletedReactionsState = deleteReactionsStateForActorChain(c, blockchainName);
int deletedConnectionsState = deleteConnectionsStateForLogin(c, login);
int deletedUsersParams = deleteUsersParamsForLogin(c, login);
int deletedChannelNames = deleteChannelNamesForOwnerChain(c, blockchainName);
int deletedChat200State = deleteChat200StateForOwnerChain(c, blockchainName);
int deletedChat200Members = deleteChat200MembersForOwnerChain(c, blockchainName);
int deletedBlocks = deleteBlocksForChain(c, blockchainName);
int deletedBlockchainState = deleteBlockchainStateForChain(c, blockchainName);
c.commit();
return new CleanupResult(
login,
likesAdjusted,
repliesAdjusted,
deletedMessageStats,
deletedReactionsState,
deletedConnectionsState,
deletedUsersParams,
deletedChannelNames,
deletedChat200State,
deletedChat200Members,
deletedBlocks,
deletedBlockchainState
);
} catch (Exception e) {
try { c.rollback(); } catch (Exception ignored) {}
if (e instanceof SQLException sqlEx) throw sqlEx;
throw new SQLException("Не удалось очистить blockchain для полного resync: " + blockchainName, e);
} finally {
try { c.setAutoCommit(oldAutoCommit); } catch (Exception ignored) {}
}
}
}
private void recountAffectedLikes(Connection c)throws SQLException{
try(PreparedStatement ps=c.prepareStatement("""
UPDATE message_stats ms SET
likes_count=(SELECT COUNT(*)::INTEGER FROM reactions_state rs WHERE rs.reaction_type=1 AND rs.last_sub_type=1 AND rs.to_login=ms.to_login AND rs.to_block_number=ms.to_block_number AND rs.to_block_hash=ms.to_block_hash),
primary_likes_count=(SELECT COUNT(*)::INTEGER FROM reactions_state rs WHERE rs.reaction_type=1 AND rs.last_sub_type=1 AND rs.to_login=ms.to_login AND rs.to_block_number=ms.to_block_number AND rs.to_block_hash=ms.to_block_hash AND shine_is_primary(rs.from_login)),
shining_likes_count=(SELECT COUNT(*)::INTEGER FROM reactions_state rs WHERE rs.reaction_type=1 AND rs.last_sub_type=1 AND rs.to_login=ms.to_login AND rs.to_block_number=ms.to_block_number AND rs.to_block_hash=ms.to_block_hash AND shine_is_primary(rs.from_login) AND shine_is_shining(rs.from_login))
WHERE EXISTS(SELECT 1 FROM shine_cleanup_targets t WHERE t.to_login=ms.to_login AND t.to_block_number=ms.to_block_number AND t.to_block_hash=ms.to_block_hash)
""")){ps.executeUpdate();}
private String resolveLoginForCleanup(Connection c, String blockchainName) throws SQLException {
String sql = """
SELECT login
FROM blockchain_state
WHERE blockchain_name = ?
LIMIT 1
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, blockchainName);
try (ResultSet rs = ps.executeQuery()) {
if (rs.next()) {
String login = rs.getString("login");
if (login != null && !login.isBlank()) {
return login;
}
}
}
}
String loginFromName = loginFromBlockchainName(blockchainName);
if (loginFromName == null || loginFromName.isBlank()) {
throw new IllegalArgumentException("Cannot derive login from blockchainName: " + blockchainName);
}
return loginFromName;
}
private void recountAffectedReplies(Connection c)throws SQLException{
try(PreparedStatement ps=c.prepareStatement("""
UPDATE message_stats ms SET replies_count=(
SELECT COUNT(*)::INTEGER FROM blocks_store b
WHERE b.msg_type=1 AND b.msg_sub_type=20
AND LOWER(b.to_login)=LOWER(ms.to_login)
AND b.to_block_number=ms.to_block_number AND b.to_block_hash=ms.to_block_hash
/**
* DAO остаётся в модуле БД и не тянет зависимость на blockchain-utils модуль.
* Поэтому здесь локально повторяем минимальное правило имени chain:
* login + "-NNN".
*/
private String loginFromBlockchainName(String blockchainName) {
if (blockchainName == null) return null;
String s = blockchainName.trim();
if (s.length() <= BLOCKCHAIN_LOGIN_SUFFIX_LEN) return null;
int dashPos = s.length() - BLOCKCHAIN_LOGIN_SUFFIX_LEN;
if (s.charAt(dashPos) != '-') return null;
for (int i = dashPos + 1; i < s.length(); i++) {
char ch = s.charAt(i);
if (ch < '0' || ch > '9') return null;
}
return s.substring(0, dashPos);
}
/**
* Уменьшаем likes_count только для ЧУЖИХ целей.
*
* Логика:
* - если у удаляемой цепочки финальное состояние реакции на цель = LIKE,
* значит при полном удалении цепочки этот активный лайк исчезает;
* - значит у message_stats этой чужой цели нужно сделать -1;
* - для целей внутри этой же chain этого делать не нужно, потому что сами цели
* тоже будут удалены вместе с цепочкой.
*/
private int decreaseForeignLikesCount(Connection c, String blockchainName) throws SQLException {
String sql = """
UPDATE message_stats
SET likes_count = GREATEST(
0,
likes_count - COALESCE((
SELECT COUNT(*)::int
FROM reactions_state rs
WHERE rs.from_bch_name = ?
AND rs.reaction_type = ?
AND rs.last_sub_type = ?
AND rs.to_login = message_stats.to_login
AND rs.to_bch_name = message_stats.to_bch_name
AND rs.to_block_number = message_stats.to_block_number
AND rs.to_block_hash = message_stats.to_block_hash
AND rs.to_bch_name <> ?
), 0)
)
WHERE EXISTS(SELECT 1 FROM shine_cleanup_reply_targets t
WHERE LOWER(t.to_login)=LOWER(ms.to_login) AND t.to_block_number=ms.to_block_number AND t.to_block_hash=ms.to_block_hash)
""")){ps.executeUpdate();}
}
private void refreshAffectedChannelStats(Connection c)throws SQLException{
try(PreparedStatement q=c.prepareStatement("SELECT owner_bch_name,root_number,root_hash FROM shine_cleanup_channels"); ResultSet rs=q.executeQuery(); PreparedStatement p=c.prepareStatement("SELECT shine_refresh_channel_follow_stats(?,?,?)")){
while(rs.next()){p.setString(1,rs.getString(1));p.setInt(2,rs.getInt(2));p.setBytes(3,rs.getBytes(3));p.execute();}
WHERE EXISTS (
SELECT 1
FROM reactions_state rs
WHERE rs.from_bch_name = ?
AND rs.reaction_type = ?
AND rs.last_sub_type = ?
AND rs.to_login = message_stats.to_login
AND rs.to_bch_name = message_stats.to_bch_name
AND rs.to_block_number = message_stats.to_block_number
AND rs.to_block_hash = message_stats.to_block_hash
AND rs.to_bch_name <> ?
)
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
int i = 1;
ps.setString(i++, blockchainName);
ps.setInt(i++, DatabaseInitializer.REACTION_LIKE);
ps.setInt(i++, DatabaseInitializer.REACTION_LIKE);
ps.setString(i++, blockchainName);
ps.setString(i++, blockchainName);
ps.setInt(i++, DatabaseInitializer.REACTION_LIKE);
ps.setInt(i++, DatabaseInitializer.REACTION_LIKE);
ps.setString(i++, blockchainName);
return ps.executeUpdate();
}
}
private void refreshAffectedUserStats(Connection c)throws SQLException{
try(PreparedStatement q=c.prepareStatement("SELECT login FROM shine_cleanup_users"); ResultSet rs=q.executeQuery(); PreparedStatement p=c.prepareStatement("SELECT shine_refresh_user_stats(?)")){
while(rs.next()){p.setString(1,rs.getString(1));p.execute();}
/**
* Уменьшаем replies_count только для ЧУЖИХ целей.
*
* Если reply этой цепочки ссылался на сообщение из другой цепочки,
* значит после удаления blocks этой цепочки чужой replies_count должен уменьшиться.
* Reply на собственные сообщения здесь игнорируем: целевая цепочка тоже будет удалена.
*/
private int decreaseForeignRepliesCount(Connection c, String blockchainName) throws SQLException {
String sql = """
UPDATE message_stats
SET replies_count = GREATEST(
0,
replies_count - COALESCE((
SELECT COUNT(*)::int
FROM blocks b
WHERE b.bch_name = ?
AND b.msg_type = 1
AND b.msg_sub_type = ?
AND b.to_login = message_stats.to_login
AND b.to_bch_name = message_stats.to_bch_name
AND b.to_block_number = message_stats.to_block_number
AND b.to_block_hash = message_stats.to_block_hash
AND b.to_bch_name <> ?
), 0)
)
WHERE EXISTS (
SELECT 1
FROM blocks b
WHERE b.bch_name = ?
AND b.msg_type = 1
AND b.msg_sub_type = ?
AND b.to_login = message_stats.to_login
AND b.to_bch_name = message_stats.to_bch_name
AND b.to_block_number = message_stats.to_block_number
AND b.to_block_hash = message_stats.to_block_hash
AND b.to_bch_name <> ?
)
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
int i = 1;
ps.setString(i++, blockchainName);
ps.setInt(i++, DatabaseInitializer.TEXT_REPLY);
ps.setString(i++, blockchainName);
ps.setString(i++, blockchainName);
ps.setInt(i++, DatabaseInitializer.TEXT_REPLY);
ps.setString(i++, blockchainName);
return ps.executeUpdate();
}
}
private int delete(Connection c,String sql,String v)throws SQLException{try(PreparedStatement ps=c.prepareStatement(sql)){ps.setString(1,v);return ps.executeUpdate();}}
private record ChainRef(String login,int fork){}
private static ChainRef chainRef(String n){ if(n==null)throw new IllegalArgumentException("blockchainName is null"); String s=n.trim();int d=s.lastIndexOf('-');if(d<=0||s.length()-d-1!=3)throw new IllegalArgumentException("Bad blockchainName: "+n);try{int f=Integer.parseInt(s.substring(d+1));if(f<1||f>999)throw new IllegalArgumentException("fork out of range");return new ChainRef(s.substring(0,d),f);}catch(NumberFormatException e){throw new IllegalArgumentException("Bad blockchainName: "+n,e);} }
/**
* Статистика сообщений самой удаляемой цепочки после reset не нужна,
* потому что её цели исчезают вместе с chain source data.
*/
private int deleteMessageStatsForOwnTargets(Connection c, String blockchainName) throws SQLException {
return executeDelete(c, """
DELETE FROM message_stats
WHERE to_bch_name = ?
""", blockchainName);
}
public record CleanupResult(String login,int deletedReactionsStateRows,int deletedConnectionsStateRows,int deletedUsersParamsRows,int deletedChannelNamesRows,int deletedChat200StateRows,int deletedChat200MembersRows,int deletedBlocksRows,int deletedBlockchainStateRows){}
/**
* reactions_state хранит финальное состояние реакций АКТОРА.
* После удаления всей цепочки актор этой цепочки исчезает, поэтому
* достаточно удалить все строки по from_bch_name.
*/
private int deleteReactionsStateForActorChain(Connection c, String blockchainName) throws SQLException {
return executeDelete(c, """
DELETE FROM reactions_state
WHERE from_bch_name = ?
""", blockchainName);
}
/**
* connections_state — текущее состояние связей, выставленных этим login.
* Чистим по владельцу состояния.
*/
private int deleteConnectionsStateForLogin(Connection c, String login) throws SQLException {
return executeDelete(c, """
DELETE FROM connections_state
WHERE LOWER(login) = LOWER(?)
""", login);
}
/**
* users_params — актуальные параметры, собранные из блоков пользователя.
*/
private int deleteUsersParamsForLogin(Connection c, String login) throws SQLException {
return executeDelete(c, """
DELETE FROM users_params
WHERE LOWER(login) = LOWER(?)
""", login);
}
/**
* Каналы принадлежат owner_bch_name.
*/
private int deleteChannelNamesForOwnerChain(Connection c, String blockchainName) throws SQLException {
return executeDelete(c, """
DELETE FROM channel_names_state
WHERE owner_bch_name = ?
""", blockchainName);
}
private int deleteChat200StateForOwnerChain(Connection c, String blockchainName) throws SQLException {
return executeDelete(c, """
DELETE FROM chat200_state
WHERE owner_bch_name = ?
""", blockchainName);
}
private int deleteChat200MembersForOwnerChain(Connection c, String blockchainName) throws SQLException {
return executeDelete(c, """
DELETE FROM chat200_members_state
WHERE owner_bch_name = ?
""", blockchainName);
}
/**
* blocks удаляем в конце, потому что до этого шага они нужны как источник правды
* для уменьшения replies_count.
*/
private int deleteBlocksForChain(Connection c, String blockchainName) throws SQLException {
return executeDelete(c, """
DELETE FROM blocks
WHERE bch_name = ?
""", blockchainName);
}
/**
* blockchain_state удаляем после blocks, чтобы не нарушать FK-связь blocks -> blockchain_state.
*/
private int deleteBlockchainStateForChain(Connection c, String blockchainName) throws SQLException {
return executeDelete(c, """
DELETE FROM blockchain_state
WHERE blockchain_name = ?
""", blockchainName);
}
private int executeDelete(Connection c, String sql, String value) throws SQLException {
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, value);
return ps.executeUpdate();
}
}
/**
* Технический результат cleanup-операции.
* Нужен для будущего логирования и ручной диагностики resync-flow.
*/
public record CleanupResult(
String login,
int likesAdjustedRows,
int repliesAdjustedRows,
int deletedMessageStatsRows,
int deletedReactionsStateRows,
int deletedConnectionsStateRows,
int deletedUsersParamsRows,
int deletedChannelNamesRows,
int deletedChat200StateRows,
int deletedChat200MembersRows,
int deletedBlocksRows,
int deletedBlockchainStateRows
) {}
}
@@ -34,8 +34,8 @@ public final class BlockchainStateDAO {
public BlockchainStateEntry getByBlockchainName(Connection c, String blockchainName) throws SQLException {
String sql = """
SELECT
blockchain_name,
login,
fork_number,
blockchain_key,
size_limit,
file_size_bytes,
@@ -43,13 +43,11 @@ public final class BlockchainStateDAO {
last_block_hash,
updated_at_ms
FROM blockchain_state
WHERE LOWER(login) = LOWER(?) AND fork_number = ?
WHERE blockchain_name = ?
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ChainRef r=chainRef(blockchainName);
ps.setString(1, r.login());
ps.setInt(2, r.fork());
ps.setString(1, blockchainName);
try (ResultSet rs = ps.executeQuery()) {
if (!rs.next()) return null;
return mapRow(rs);
@@ -68,8 +66,8 @@ public final class BlockchainStateDAO {
public List<BlockchainStateEntry> listAll(Connection c) throws SQLException {
String sql = """
SELECT
blockchain_name,
login,
fork_number,
blockchain_key,
size_limit,
file_size_bytes,
@@ -77,7 +75,7 @@ public final class BlockchainStateDAO {
last_block_hash,
updated_at_ms
FROM blockchain_state
ORDER BY LOWER(login), fork_number
ORDER BY LOWER(blockchain_name)
""";
List<BlockchainStateEntry> result = new ArrayList<>();
@@ -100,9 +98,9 @@ public final class BlockchainStateDAO {
/** UPSERT с внешним соединением. Соединение НЕ закрывает. */
public void upsert(Connection c, BlockchainStateEntry e) throws SQLException {
String sql = """
INSERT INTO blockchain_state_store (
INSERT INTO blockchain_state (
blockchain_name,
login,
fork_number,
blockchain_key,
size_limit,
file_size_bytes,
@@ -110,8 +108,9 @@ public final class BlockchainStateDAO {
last_block_hash,
updated_at_ms
) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(login, fork_number)
ON CONFLICT(blockchain_name)
DO UPDATE SET
login = excluded.login,
blockchain_key = excluded.blockchain_key,
size_limit = excluded.size_limit,
file_size_bytes = excluded.file_size_bytes,
@@ -123,8 +122,8 @@ public final class BlockchainStateDAO {
try (PreparedStatement ps = c.prepareStatement(sql)) {
int i = 1;
ps.setString(i++, e.getBlockchainName());
ps.setString(i++, nn(e.getLogin()));
ps.setInt(i++, e.getForkNumber());
ps.setString(i++, nn(e.getBlockchainKey()));
ps.setLong(i++, e.getSizeLimit());
@@ -149,9 +148,9 @@ public final class BlockchainStateDAO {
*/
public boolean insertIfMissing(Connection c, BlockchainStateEntry e) throws SQLException {
String sql = """
INSERT INTO blockchain_state_store (
INSERT INTO blockchain_state (
blockchain_name,
login,
fork_number,
blockchain_key,
size_limit,
file_size_bytes,
@@ -159,14 +158,14 @@ public final class BlockchainStateDAO {
last_block_hash,
updated_at_ms
) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(login, fork_number) DO NOTHING
ON CONFLICT(blockchain_name) DO NOTHING
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
int i = 1;
ps.setString(i++, e.getBlockchainName());
ps.setString(i++, nn(e.getLogin()));
ps.setInt(i++, e.getForkNumber());
ps.setString(i++, nn(e.getBlockchainKey()));
ps.setLong(i++, e.getSizeLimit());
@@ -192,22 +191,20 @@ public final class BlockchainStateDAO {
*/
public boolean tryIncreaseFileSizeWithinLimit(Connection c, String blockchainName, long deltaBytes, long nowMs) throws SQLException {
String sql = """
UPDATE blockchain_state_store
UPDATE blockchain_state
SET
file_size_bytes = file_size_bytes + ?,
updated_at_ms = ?
WHERE
LOWER(login) = LOWER(?) AND fork_number = ?
blockchain_name = ?
AND (file_size_bytes + ?) <= size_limit
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setLong(1, deltaBytes);
ps.setLong(2, nowMs);
ChainRef r=chainRef(blockchainName);
ps.setString(3, r.login());
ps.setInt(4, r.fork());
ps.setLong(5, deltaBytes);
ps.setString(3, blockchainName);
ps.setLong(4, deltaBytes);
return ps.executeUpdate() > 0;
}
}
@@ -215,8 +212,8 @@ public final class BlockchainStateDAO {
private BlockchainStateEntry mapRow(ResultSet rs) throws SQLException {
BlockchainStateEntry e = new BlockchainStateEntry();
e.setBlockchainName(rs.getString("blockchain_name"));
e.setLogin(rs.getString("login"));
e.setForkNumber(rs.getInt("fork_number"));
e.setBlockchainKey(rs.getString("blockchain_key"));
e.setSizeLimit(rs.getLong("size_limit"));
@@ -230,15 +227,6 @@ public final class BlockchainStateDAO {
return e;
}
private record ChainRef(String login,int fork) {}
private static ChainRef chainRef(String name) {
if(name==null) throw new IllegalArgumentException("blockchainName is null");
String s=name.trim(); int d=s.lastIndexOf('-');
if(d<=0 || s.length()-d-1 != 3) throw new IllegalArgumentException("Bad blockchainName: "+name);
try { int f=Integer.parseInt(s.substring(d+1)); if(f<1||f>999) throw new IllegalArgumentException("fork out of range"); return new ChainRef(s.substring(0,d),f); }
catch(NumberFormatException e){ throw new IllegalArgumentException("Bad blockchainName: "+name,e); }
}
private static void setBytesNullable(PreparedStatement ps, int index, byte[] b) throws SQLException {
if (b != null) ps.setBytes(index, b);
else ps.setNull(index, Types.BINARY);
@@ -9,183 +9,286 @@ import java.sql.*;
import java.util.ArrayList;
import java.util.List;
/** DAO for SHiNE Frame v1 blocks. block_bytes contains the complete ANS-104 DataItem. */
/**
* DAO для таблицы blocks (новый формат).
*
* Правило:
* - методы с Connection НЕ закрывают соединение
* - методы без Connection сами открывают и закрывают соединение
*
* Ключ:
* - (bch_name, block_number) — уникальная пара в рамках общей БД сервера.
*/
public final class BlocksDAO {
private static volatile BlocksDAO instance;
private final DbController db = DbController.getInstance();
private static final Logger log = LoggerFactory.getLogger(BlocksDAO.class);
private BlocksDAO() { }
public static BlocksDAO getInstance() {
if (instance == null) synchronized (BlocksDAO.class) { if (instance == null) instance = new BlocksDAO(); }
if (instance == null) {
synchronized (BlocksDAO.class) {
if (instance == null) instance = new BlocksDAO();
}
}
return instance;
}
// -------------------- INSERT --------------------
/** Вставка с внешним соединением. Соединение НЕ закрывает. */
public void insert(Connection c, BlockEntry e) throws SQLException {
log.info("DBG BlockEntry: type={} sub={} lineCode={} prevLineNumber={} thisLineNumber={} prevLineHashLen={}",
e.getMsgType(), e.getMsgSubType(),
e.getLineCode(), e.getPrevLineNumber(), e.getThisLineNumber(),
e.getPrevLineHash() == null ? null : e.getPrevLineHash().length
);
String sql = """
INSERT INTO blocks_store (
login,fork_number,block_number,msg_type,msg_sub_type,block_bytes,
to_login,to_fork_number,to_block_number,to_block_hash,
block_hash,block_signature,data_item_id,
arweave_publish_pending,arweave_published_at_ms,
edited_by_block_number,line_code,prev_line_number,prev_line_hash,this_line_number
) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
INSERT INTO blocks (
login,
bch_name,
block_number,
msg_type,
msg_sub_type,
block_bytes,
to_login,
to_bch_name,
to_block_number,
to_block_hash,
block_hash,
block_signature,
edited_by_block_number,
line_code,
prev_line_number,
prev_line_hash,
this_line_number
) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
int i = 1;
ps.setString(i++, e.getLogin());
ps.setInt(i++, e.getForkNumber());
ps.setString(i++, e.getBchName());
ps.setInt(i++, e.getBlockNumber());
ps.setInt(i++, e.getMsgType());
ps.setInt(i++, e.getMsgSubType());
ps.setBytes(i++, e.getBlockBytes());
setNullableString(ps, i++, e.getToLogin());
setNullableInt(ps, i++, e.getToForkNumber());
setNullableInt(ps, i++, e.getToBlockNumber());
setNullableBytes(ps, i++, e.getToBlockHash());
if (e.getToLogin() != null) ps.setString(i++, e.getToLogin());
else ps.setNull(i++, Types.VARCHAR);
if (e.getToBchName() != null) ps.setString(i++, e.getToBchName());
else ps.setNull(i++, Types.VARCHAR);
if (e.getToBlockNumber() != null) ps.setInt(i++, e.getToBlockNumber());
else ps.setNull(i++, Types.INTEGER);
if (e.getToBlockHash() != null) ps.setBytes(i++, e.getToBlockHash());
else ps.setNull(i++, Types.BINARY);
ps.setBytes(i++, e.getBlockHash());
ps.setBytes(i++, e.getBlockSignature());
ps.setBytes(i++, e.getDataItemId());
ps.setBoolean(i++, e.isArweavePublishPending());
if (e.getArweavePublishedAtMs() == null) ps.setNull(i++, Types.BIGINT); else ps.setLong(i++, e.getArweavePublishedAtMs());
setNullableInt(ps, i++, e.getEditedByBlockNumber());
setNullableInt(ps, i++, e.getLineCode());
setNullableInt(ps, i++, e.getPrevLineNumber());
setNullableBytes(ps, i++, e.getPrevLineHash());
setNullableInt(ps, i++, e.getThisLineNumber());
if (e.getEditedByBlockNumber() != null) ps.setInt(i++, e.getEditedByBlockNumber());
else ps.setNull(i++, Types.INTEGER);
// NEW: line_code
if (e.getLineCode() != null) ps.setInt(i++, e.getLineCode());
else ps.setNull(i++, Types.INTEGER);
if (e.getPrevLineNumber() != null) ps.setInt(i++, e.getPrevLineNumber());
else ps.setNull(i++, Types.INTEGER);
if (e.getPrevLineHash() != null) ps.setBytes(i++, e.getPrevLineHash());
else ps.setNull(i++, Types.BINARY);
if (e.getThisLineNumber() != null) ps.setInt(i++, e.getThisLineNumber());
else ps.setNull(i++, Types.INTEGER);
ps.executeUpdate();
}
}
public void insert(BlockEntry e) throws SQLException { try (Connection c = db.getConnection()) { insert(c, e); } }
public boolean existsByDataItemId(byte[] dataItemId) throws SQLException {
if (dataItemId == null || dataItemId.length != 32) return false;
try (Connection c = db.getConnection();
PreparedStatement ps = c.prepareStatement("SELECT 1 FROM blocks WHERE data_item_id=? LIMIT 1")) {
ps.setBytes(1, dataItemId);
try (ResultSet rs = ps.executeQuery()) { return rs.next(); }
}
}
/** Возвращает ещё не опубликованный пользовательский DataItem для быстрой Turbo-попытки. */
public BlockEntry getPendingArweaveByDataItemId(byte[] dataItemId) throws SQLException {
if (dataItemId == null || dataItemId.length != 32) return null;
String sql = baseSelect() + " WHERE data_item_id=? AND arweave_publish_pending=TRUE LIMIT 1";
try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(sql)) {
ps.setBytes(1, dataItemId);
try (ResultSet rs = ps.executeQuery()) { return rs.next() ? mapRow(rs) : null; }
}
}
public List<BlockEntry> listPendingArweave(int limit) throws SQLException {
int safeLimit = Math.max(1, Math.min(limit, 100_000));
String sql = """
SELECT login,fork_number,block_number,msg_type,msg_sub_type,block_bytes,
to_login,to_fork_number,to_block_number,to_block_hash,block_hash,block_signature,data_item_id,
arweave_publish_pending,arweave_published_at_ms,
edited_by_block_number,line_code,prev_line_number,prev_line_hash,this_line_number
FROM blocks
WHERE arweave_publish_pending = TRUE
ORDER BY login ASC, fork_number ASC, block_number ASC
LIMIT ?
""";
List<BlockEntry> out = new ArrayList<>();
try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(sql)) {
ps.setInt(1, safeLimit);
try (ResultSet rs = ps.executeQuery()) { while (rs.next()) out.add(mapRow(rs)); }
}
return out;
}
public void markArweavePublished(List<byte[]> dataItemIds, long publishedAtMs) throws SQLException {
if (dataItemIds == null || dataItemIds.isEmpty()) return;
String sql = """
UPDATE blocks_store
SET arweave_publish_pending=FALSE, arweave_published_at_ms=?
WHERE data_item_id=?
""";
/** Вставка без внешнего соединения. Сам открывает/закрывает. */
public void insert(BlockEntry e) throws SQLException {
try (Connection c = db.getConnection()) {
c.setAutoCommit(false);
try (PreparedStatement ps = c.prepareStatement(sql)) {
for (byte[] id : dataItemIds) {
ps.setLong(1, publishedAtMs); ps.setBytes(2, id); ps.addBatch();
}
ps.executeBatch(); c.commit();
} catch (Exception e) { c.rollback(); throw e; }
finally { c.setAutoCommit(true); }
insert(c, e);
}
}
// -------------------- SELECT: HASH BY NUMBER --------------------
/** Получить block_hash по (bch_name, block_number). Нужен для линейной проверки. */
public byte[] getHashByNumber(Connection c, String bchName, int blockNumber) throws SQLException {
try (PreparedStatement ps = c.prepareStatement("SELECT block_hash FROM blocks WHERE login=? AND fork_number=? AND block_number=? LIMIT 1")) {
ChainRef r=chainRef(bchName); ps.setString(1,r.login()); ps.setInt(2,r.fork()); ps.setInt(3,blockNumber);
try (ResultSet rs=ps.executeQuery()) { return rs.next()?rs.getBytes(1):null; }
String sql = """
SELECT block_hash
FROM blocks
WHERE bch_name = ? AND block_number = ?
LIMIT 1
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, bchName);
ps.setInt(2, blockNumber);
try (ResultSet rs = ps.executeQuery()) {
if (!rs.next()) return null;
return rs.getBytes("block_hash");
}
}
}
public byte[] getHashByNumber(String bchName, int blockNumber) throws SQLException { try(Connection c=db.getConnection()){return getHashByNumber(c,bchName,blockNumber);} }
public byte[] getHashByNumber(String bchName, int blockNumber) throws SQLException {
try (Connection c = db.getConnection()) {
return getHashByNumber(c, bchName, blockNumber);
}
}
// -------------------- SELECT: FULL ENTRY --------------------
public BlockEntry getByNumber(Connection c, String bchName, int blockNumber) throws SQLException {
String sql = baseSelect()+" WHERE login=? AND fork_number=? AND block_number=? LIMIT 1";
ChainRef r=chainRef(bchName);
try(PreparedStatement ps=c.prepareStatement(sql)){ ps.setString(1,r.login()); ps.setInt(2,r.fork()); ps.setInt(3,blockNumber); try(ResultSet rs=ps.executeQuery()){return rs.next()?mapRow(rs):null;} }
}
public BlockEntry getByNumber(String bchName,int blockNumber)throws SQLException{try(Connection c=db.getConnection()){return getByNumber(c,bchName,blockNumber);} }
String sql = """
SELECT
login,
bch_name,
block_number,
msg_type,
msg_sub_type,
block_bytes,
to_login,
to_bch_name,
to_block_number,
to_block_hash,
block_hash,
block_signature,
edited_by_block_number,
line_code,
prev_line_number,
prev_line_hash,
this_line_number
FROM blocks
WHERE bch_name = ? AND block_number = ?
LIMIT 1
""";
/** Последний принятый блок конкретной логической линии в текущем physical fork. */
public BlockEntry getLastLineBlock(Connection c, String bchName, int msgType, int lineCode) throws SQLException {
String sql = baseSelect()+" WHERE login=? AND fork_number=? AND msg_type=? AND line_code=? ORDER BY block_number DESC LIMIT 1";
ChainRef r=chainRef(bchName);
try(PreparedStatement ps=c.prepareStatement(sql)){
ps.setString(1,r.login()); ps.setInt(2,r.fork()); ps.setInt(3,msgType); ps.setInt(4,lineCode);
try(ResultSet rs=ps.executeQuery()){ return rs.next()?mapRow(rs):null; }
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, bchName);
ps.setInt(2, blockNumber);
try (ResultSet rs = ps.executeQuery()) {
if (!rs.next()) return null;
return mapRow(rs);
}
}
}
public BlockEntry getLastLineBlock(String bchName, int msgType, int lineCode) throws SQLException {
try(Connection c=db.getConnection()){ return getLastLineBlock(c,bchName,msgType,lineCode); }
public BlockEntry getByNumber(String bchName, int blockNumber) throws SQLException {
try (Connection c = db.getConnection()) {
return getByNumber(c, bchName, blockNumber);
}
}
public List<BlockEntry> listRangeByNumber(String bchName,int from,int to)throws SQLException{try(Connection c=db.getConnection()){return listRangeByNumber(c,bchName,from,to);} }
public List<BlockEntry> listRangeByNumber(Connection c,String bchName,int from,int to)throws SQLException{
String sql=baseSelect()+" WHERE login=? AND fork_number=? AND block_number>=? AND block_number<=? ORDER BY block_number ASC";
List<BlockEntry> out=new ArrayList<>();
ChainRef r=chainRef(bchName);
try(PreparedStatement ps=c.prepareStatement(sql)){ps.setString(1,r.login());ps.setInt(2,r.fork());ps.setInt(3,from);ps.setInt(4,to);try(ResultSet rs=ps.executeQuery()){while(rs.next())out.add(mapRow(rs));}}
return out;
public List<BlockEntry> listRangeByNumber(String bchName, int fromBlockNumberInclusive, int toBlockNumberInclusive) throws SQLException {
try (Connection c = db.getConnection()) {
return listRangeByNumber(c, bchName, fromBlockNumberInclusive, toBlockNumberInclusive);
}
}
private static String baseSelect(){return """
SELECT login,fork_number,block_number,msg_type,msg_sub_type,block_bytes,
to_login,to_fork_number,to_block_number,to_block_hash,block_hash,block_signature,data_item_id,
arweave_publish_pending,arweave_published_at_ms,
edited_by_block_number,line_code,prev_line_number,prev_line_hash,this_line_number
FROM blocks
""";}
public List<BlockEntry> listRangeByNumber(Connection c, String bchName, int fromBlockNumberInclusive, int toBlockNumberInclusive) throws SQLException {
String sql = """
SELECT
login,
bch_name,
block_number,
msg_type,
msg_sub_type,
block_bytes,
to_login,
to_bch_name,
to_block_number,
to_block_hash,
block_hash,
block_signature,
edited_by_block_number,
line_code,
prev_line_number,
prev_line_hash,
this_line_number
FROM blocks
WHERE bch_name = ?
AND block_number >= ?
AND block_number <= ?
ORDER BY block_number ASC
""";
List<BlockEntry> result = new ArrayList<>();
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, bchName);
ps.setInt(2, fromBlockNumberInclusive);
ps.setInt(3, toBlockNumberInclusive);
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
result.add(mapRow(rs));
}
}
}
return result;
}
// -------------------- INTERNAL --------------------
private BlockEntry mapRow(ResultSet rs) throws SQLException {
BlockEntry e = new BlockEntry();
e.setLogin(rs.getString("login"));
e.setBchName(rs.getString("bch_name"));
e.setBlockNumber(rs.getInt("block_number"));
e.setMsgType(rs.getInt("msg_type"));
e.setMsgSubType(rs.getInt("msg_sub_type"));
e.setBlockBytes(rs.getBytes("block_bytes"));
String toLogin = rs.getString("to_login");
if (rs.wasNull()) toLogin = null;
e.setToLogin(toLogin);
String toBchName = rs.getString("to_bch_name");
if (rs.wasNull()) toBchName = null;
e.setToBchName(toBchName);
Integer toBlockNumber = (Integer) rs.getObject("to_block_number");
e.setToBlockNumber(toBlockNumber);
byte[] toHash = rs.getBytes("to_block_hash");
if (rs.wasNull()) toHash = null;
e.setToBlockHash(toHash);
e.setBlockHash(rs.getBytes("block_hash"));
e.setBlockSignature(rs.getBytes("block_signature"));
Integer editedBy = (Integer) rs.getObject("edited_by_block_number");
e.setEditedByBlockNumber(editedBy);
// NEW: line_code
Integer lineCode = (Integer) rs.getObject("line_code");
e.setLineCode(lineCode);
Integer prevLn = (Integer) rs.getObject("prev_line_number");
e.setPrevLineNumber(prevLn);
byte[] prevLh = rs.getBytes("prev_line_hash");
if (rs.wasNull()) prevLh = null;
e.setPrevLineHash(prevLh);
Integer thisLn = (Integer) rs.getObject("this_line_number");
e.setThisLineNumber(thisLn);
private BlockEntry mapRow(ResultSet rs)throws SQLException{
BlockEntry e=new BlockEntry();
e.setLogin(rs.getString("login")); e.setForkNumber(rs.getInt("fork_number")); e.setBlockNumber(rs.getInt("block_number"));
e.setMsgType(rs.getInt("msg_type")); e.setMsgSubType(rs.getInt("msg_sub_type")); e.setBlockBytes(rs.getBytes("block_bytes"));
e.setToLogin(rs.getString("to_login")); e.setToForkNumber((Integer)rs.getObject("to_fork_number")); e.setToBlockNumber((Integer)rs.getObject("to_block_number")); e.setToBlockHash(rs.getBytes("to_block_hash"));
e.setBlockHash(rs.getBytes("block_hash")); e.setBlockSignature(rs.getBytes("block_signature")); e.setDataItemId(rs.getBytes("data_item_id"));
e.setArweavePublishPending(rs.getBoolean("arweave_publish_pending")); e.setArweavePublishedAtMs((Long)rs.getObject("arweave_published_at_ms"));
e.setEditedByBlockNumber((Integer)rs.getObject("edited_by_block_number")); e.setLineCode((Integer)rs.getObject("line_code")); e.setPrevLineNumber((Integer)rs.getObject("prev_line_number")); e.setPrevLineHash(rs.getBytes("prev_line_hash")); e.setThisLineNumber((Integer)rs.getObject("this_line_number"));
return e;
}
private record ChainRef(String login, int fork) {}
private static ChainRef chainRef(String name) {
if (name == null) throw new IllegalArgumentException("blockchainName is null");
String s=name.trim(); int dash=s.lastIndexOf('-');
if (dash <= 0 || s.length()-dash-1 != 3) throw new IllegalArgumentException("Bad blockchainName: "+name);
try {
int fork=Integer.parseInt(s.substring(dash+1));
if (fork < 1 || fork > 999) throw new IllegalArgumentException("fork out of range: "+name);
return new ChainRef(s.substring(0,dash),fork);
} catch(NumberFormatException ex){ throw new IllegalArgumentException("Bad blockchainName: "+name,ex); }
}
private static void setNullableString(PreparedStatement ps,int i,String v)throws SQLException{if(v==null)ps.setNull(i,Types.VARCHAR);else ps.setString(i,v);}
private static void setNullableInt(PreparedStatement ps,int i,Integer v)throws SQLException{if(v==null)ps.setNull(i,Types.INTEGER);else ps.setInt(i,v);}
private static void setNullableBytes(PreparedStatement ps,int i,byte[] v)throws SQLException{if(v==null)ps.setNull(i,Types.BINARY);else ps.setBytes(i,v);}
}
@@ -1,36 +0,0 @@
package shine.db.dao;
import shine.db.DbController;
import shine.db.entities.BlockEntry;
import java.sql.*;
/** Resolves a logical block number to the physical fork that owns it in a selected canonical history. */
public final class CanonicalChainResolver {
private static volatile CanonicalChainResolver instance;
private final DbController db=DbController.getInstance();
private final BlocksDAO blocks=BlocksDAO.getInstance();
private final BlockchainForkSegmentsDAO segments=BlockchainForkSegmentsDAO.getInstance();
private CanonicalChainResolver(){}
public static CanonicalChainResolver getInstance(){if(instance==null)synchronized(CanonicalChainResolver.class){if(instance==null)instance=new CanonicalChainResolver();}return instance;}
public BlockEntry getBlock(String blockchainName,int blockNumber)throws SQLException{try(Connection c=db.getConnection()){return getBlock(c,blockchainName,blockNumber);}}
public BlockEntry getBlock(Connection c,String blockchainName,int blockNumber)throws SQLException{
ChainRef r=ref(blockchainName); int physical=resolveFork(c,r.login,r.fork,blockNumber); return blocks.getByNumber(c,r.login+"-"+String.format("%03d",physical),blockNumber);
}
public byte[] getHash(String blockchainName,int blockNumber)throws SQLException{BlockEntry b=getBlock(blockchainName,blockNumber);return b==null?null:b.getBlockHash();}
public byte[] getHash(Connection c,String blockchainName,int blockNumber)throws SQLException{BlockEntry b=getBlock(c,blockchainName,blockNumber);return b==null?null:b.getBlockHash();}
public int resolveFork(Connection c,String login,int activeFork,int blockNumber)throws SQLException{
if(blockNumber<0)throw new IllegalArgumentException("blockNumber < 0"); int f=activeFork; int guard=0;
while(true){ if(++guard>1000)throw new SQLException("fork ancestry cycle for "+login); BlockchainForkSegmentsDAO.Segment s=segments.get(c,login,f);
if(s==null){ // legacy self-contained fork
return f;
}
if(s.parentForkNumber()==null || blockNumber>=s.firstPhysicalBlockNumber()) return f;
f=s.parentForkNumber();
}
}
public BlockEntry getLastLineBlock(Connection c,String blockchainName,int msgType,int lineCode,int beforeBlockExclusive)throws SQLException{
ChainRef r=ref(blockchainName); for(int n=beforeBlockExclusive-1;n>=0;n--){ BlockEntry b=getBlock(c,blockchainName,n); if(b!=null && b.getMsgType()==msgType && b.getLineCode()!=null && b.getLineCode()==lineCode)return b; } return null;
}
private record ChainRef(String login,int fork){}
private static ChainRef ref(String n){int d=n==null?-1:n.lastIndexOf('-');if(d<=0||n.length()-d-1!=3)throw new IllegalArgumentException("Bad blockchainName: "+n);return new ChainRef(n.substring(0,d),Integer.parseInt(n.substring(d+1)));}
}
@@ -28,11 +28,11 @@ public final class ChannelNameStateDAO {
String sql = """
SELECT 1
FROM channel_names_state
WHERE LOWER(owner_login) = LOWER(?) AND channel_type_code = ? AND slug = ?
WHERE owner_bch_name = ? AND channel_type_code = ? AND slug = ?
LIMIT 1
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, loginOf(ownerBchName));
ps.setString(1, ownerBchName);
ps.setInt(2, channelTypeCode);
ps.setString(3, slug);
try (ResultSet rs = ps.executeQuery()) {
@@ -100,7 +100,7 @@ public final class ChannelNameStateDAO {
ava_sha256 = ?,
ava_size = ?,
meta_updated_at_ms = ?
WHERE LOWER(owner_login)=LOWER(?) AND channel_root_block_number = ?
WHERE owner_bch_name = ? AND channel_root_block_number = ?
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, entry.getDisplayName() == null ? "" : entry.getDisplayName());
@@ -109,7 +109,7 @@ public final class ChannelNameStateDAO {
ps.setString(4, entry.getAvaSha256() == null ? "" : entry.getAvaSha256());
ps.setLong(5, Math.max(0L, entry.getAvaSize()));
ps.setLong(6, Math.max(0L, entry.getMetaUpdatedAtMs()));
ps.setString(7, entry.getOwnerLogin());
ps.setString(7, entry.getOwnerBlockchainName());
ps.setInt(8, entry.getChannelRootBlockNumber());
ps.executeUpdate();
}
@@ -120,37 +120,4 @@ public final class ChannelNameStateDAO {
insert(c, entry);
}
}
public boolean updateDeletedState(Connection c, String ownerBchName, int rootBlockNumber, boolean deleted, long deletedAtMs, Integer deletedBlockNumber) throws SQLException {
String sql = """
UPDATE channel_names_state
SET is_deleted = ?,
deleted_at_ms = ?,
deleted_block_number = ?
WHERE LOWER(owner_login) = LOWER(?)
AND channel_root_block_number = ?
AND is_deleted IS DISTINCT FROM ?
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setBoolean(1, deleted);
ps.setLong(2, deleted ? Math.max(0L, deletedAtMs) : 0L);
if (deleted && deletedBlockNumber != null) ps.setInt(3, deletedBlockNumber); else ps.setNull(3, java.sql.Types.INTEGER);
ps.setString(4, loginOf(ownerBchName));
ps.setInt(5, rootBlockNumber);
ps.setBoolean(6, deleted);
return ps.executeUpdate() > 0;
}
}
public String getSlugByOwnerAndRoot(String ownerBchName, int rootBlockNumber) throws SQLException {
String sql = "SELECT slug FROM channel_names_state WHERE LOWER(owner_login)=LOWER(?) AND channel_root_block_number=? LIMIT 1";
try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, loginOf(ownerBchName));
ps.setInt(2, rootBlockNumber);
try (ResultSet rs = ps.executeQuery()) {
return rs.next() ? rs.getString(1) : null;
}
}
}
private static String loginOf(String bch){ if(bch==null)return ""; int d=bch.lastIndexOf('-'); return d>0?bch.substring(0,d):bch; }
}
@@ -1,334 +0,0 @@
package shine.db.dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
/**
* Server projection for per-user channel read/unread state.
*
* Important rules:
* - rows are created only by a signed client SetChannelReadState;
* - channel publications increment unread_count only for rows that already exist;
* - read_count is monotonic and unread_count is reduced by the accepted read delta;
* - unread_count is never part of the client signature and is server-owned.
*/
public final class ChannelReadStateDAO {
private static volatile ChannelReadStateDAO instance;
private ChannelReadStateDAO() {}
public static ChannelReadStateDAO getInstance() {
if (instance == null) {
synchronized (ChannelReadStateDAO.class) {
if (instance == null) instance = new ChannelReadStateDAO();
}
}
return instance;
}
public record ReadState(long readCount, long unreadCount, long readUpdatedAtMs,
String clientKey, String readSignature) {}
public record UpsertResult(boolean applied, long readCount, long unreadCount) {}
public ReadState get(Connection c, String viewerLogin, String ownerBchName, String channelName) throws SQLException {
String sql = """
SELECT read_count, unread_count, read_updated_at_ms, client_key, read_signature
FROM channel_read_state
WHERE LOWER(viewer_login)=LOWER(?) AND LOWER(owner_login)=LOWER(?) AND channel_name=?
LIMIT 1
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, viewerLogin);
ps.setString(2, loginFromChainName(ownerBchName));
ps.setString(3, channelName);
try (ResultSet rs = ps.executeQuery()) {
if (!rs.next()) return null;
return new ReadState(
Math.max(0L, rs.getLong("read_count")),
Math.max(0L, rs.getLong("unread_count")),
rs.getLong("read_updated_at_ms"),
rs.getString("client_key"),
rs.getString("read_signature"));
}
}
}
public long getUnreadCount(Connection c, String viewerLogin, String ownerBchName, String channelName) throws SQLException {
ReadState state = get(c, viewerLogin, ownerBchName, channelName);
return state == null ? 0L : state.unreadCount();
}
public long sumUnreadCount(Connection c, String viewerLogin) throws SQLException {
String sql = """
SELECT COALESCE(SUM(crs.unread_count),0)
FROM channel_read_state crs
WHERE LOWER(crs.viewer_login)=LOWER(?)
AND EXISTS (
SELECT 1
FROM channel_names_state cns
JOIN connections_state cs
ON LOWER(cs.login)=LOWER(crs.viewer_login)
AND cs.rel_type=30
AND LOWER(cs.to_login)=LOWER(cns.owner_login)
AND COALESCE(cs.to_block_number,0)=cns.channel_root_block_number
AND cs.to_block_hash=cns.channel_root_block_hash
WHERE LOWER(cns.owner_login)=LOWER(crs.owner_login)
AND cns.slug=crs.channel_name
AND cns.channel_type_code=1
AND NOT cns.is_deleted
)
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, viewerLogin);
try (ResultSet rs = ps.executeQuery()) {
return rs.next() ? Math.max(0L, rs.getLong(1)) : 0L;
}
}
}
/**
* Validates that the requested public channel exists and that viewer currently follows it.
*/
public boolean hasActiveSubscription(Connection c, String viewerLogin, String ownerBchName, String channelName,
int followRelType) throws SQLException {
String sql = """
SELECT 1
FROM channel_names_state cns
JOIN connections_state cs
ON LOWER(cs.login)=LOWER(?)
AND cs.rel_type=?
AND LOWER(cs.to_login)=LOWER(cns.owner_login)
AND COALESCE(cs.to_block_number,0)=cns.channel_root_block_number
AND cs.to_block_hash=cns.channel_root_block_hash
WHERE LOWER(cns.owner_login)=LOWER(?)
AND cns.slug=?
AND cns.channel_type_code=1
LIMIT 1
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, viewerLogin);
ps.setInt(2, followRelType);
ps.setString(3, loginFromChainName(ownerBchName));
ps.setString(4, channelName);
try (ResultSet rs = ps.executeQuery()) {
return rs.next();
}
}
}
public String resolvePublicChannelNameByRoot(Connection c, String ownerBchName, int rootBlockNumber) throws SQLException {
String sql = """
SELECT slug
FROM channel_names_state
WHERE LOWER(owner_login)=LOWER(?) AND channel_root_block_number=? AND channel_type_code=1
LIMIT 1
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, loginFromChainName(ownerBchName));
ps.setInt(2, rootBlockNumber);
try (ResultSet rs = ps.executeQuery()) {
return rs.next() ? rs.getString("slug") : null;
}
}
}
public Integer resolvePublicChannelRootByName(Connection c, String ownerBchName, String channelName) throws SQLException {
String sql = """
SELECT channel_root_block_number
FROM channel_names_state
WHERE LOWER(owner_login)=LOWER(?) AND slug=? AND channel_type_code=1
LIMIT 1
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, loginFromChainName(ownerBchName));
ps.setString(2, channelName);
try (ResultSet rs = ps.executeQuery()) {
return rs.next() ? rs.getInt("channel_root_block_number") : null;
}
}
}
public String resolveOwnerLogin(Connection c, String ownerBchName, String channelName) throws SQLException {
String sql = """
SELECT owner_login
FROM channel_names_state
WHERE LOWER(owner_login)=LOWER(?) AND slug=? AND channel_type_code=1
LIMIT 1
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, loginFromChainName(ownerBchName));
ps.setString(2, channelName);
try (ResultSet rs = ps.executeQuery()) {
return rs.next() ? rs.getString("owner_login") : null;
}
}
}
/**
* Inserts the first client baseline with unread=0, or advances an existing read watermark.
* Older timestamps and backwards read_count values are ignored.
*/
public UpsertResult upsertSignedReadIfNewer(Connection c,
String viewerLogin,
String ownerLogin,
String ownerBchName,
String channelName,
long readCount,
long readUpdatedAtMs,
String clientKey,
String readSignature,
long nowMs) throws SQLException {
String sql = """
INSERT INTO channel_read_state (
viewer_login, owner_login, owner_bch_name, channel_name,
read_count, unread_count,
read_updated_at_ms, client_key, read_signature, updated_at_ms
) VALUES (?, ?, ?, ?, ?, 0, ?, ?, ?, ?)
ON CONFLICT (viewer_login, owner_login, channel_name)
DO UPDATE SET
owner_login = EXCLUDED.owner_login,
owner_bch_name = EXCLUDED.owner_bch_name,
unread_count = GREATEST(
0,
channel_read_state.unread_count -
GREATEST(0, EXCLUDED.read_count - channel_read_state.read_count)
),
read_count = GREATEST(channel_read_state.read_count, EXCLUDED.read_count),
read_updated_at_ms = EXCLUDED.read_updated_at_ms,
client_key = EXCLUDED.client_key,
read_signature = EXCLUDED.read_signature,
updated_at_ms = EXCLUDED.updated_at_ms
WHERE channel_read_state.read_updated_at_ms < EXCLUDED.read_updated_at_ms
AND EXCLUDED.read_count >= channel_read_state.read_count
RETURNING read_count, unread_count
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, viewerLogin);
ps.setString(2, ownerLogin);
ps.setString(3, loginFromChainName(ownerBchName));
ps.setString(4, channelName);
ps.setLong(5, Math.max(0L, readCount));
ps.setLong(6, readUpdatedAtMs);
ps.setString(7, clientKey);
ps.setString(8, readSignature);
ps.setLong(9, nowMs);
try (ResultSet rs = ps.executeQuery()) {
if (rs.next()) {
return new UpsertResult(true,
Math.max(0L, rs.getLong("read_count")),
Math.max(0L, rs.getLong("unread_count")));
}
}
}
ReadState current = get(c, viewerLogin, ownerBchName, channelName);
return new UpsertResult(false,
current == null ? 0L : current.readCount(),
current == null ? 0L : current.unreadCount());
}
/**
* Increments existing rows for current subscribers of one public channel.
* Missing channel_read_state rows are deliberately NOT created.
* Returns affected viewer logins for post-commit counter pushes.
*/
public List<String> incrementUnreadForSubscribers(Connection c,
String ownerBchName,
String channelName,
int followRelType,
long nowMs) throws SQLException {
String sql = """
UPDATE channel_read_state crs
SET unread_count = crs.unread_count + 1,
updated_at_ms = ?
WHERE LOWER(crs.owner_login)=LOWER(?)
AND crs.channel_name = ?
AND LOWER(crs.viewer_login) <> LOWER(crs.owner_login)
AND EXISTS (
SELECT 1
FROM channel_names_state cns
JOIN connections_state cs
ON LOWER(cs.login)=LOWER(crs.viewer_login)
AND cs.rel_type=?
AND LOWER(cs.to_login)=LOWER(cns.owner_login)
AND COALESCE(cs.to_block_number,0)=cns.channel_root_block_number
AND cs.to_block_hash=cns.channel_root_block_hash
WHERE LOWER(cns.owner_login)=LOWER(crs.owner_login)
AND cns.slug=crs.channel_name
AND cns.channel_type_code=1
)
RETURNING viewer_login
""";
List<String> affected = new ArrayList<>();
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setLong(1, nowMs);
ps.setString(2, loginFromChainName(ownerBchName));
ps.setString(3, channelName);
ps.setInt(4, followRelType);
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) affected.add(rs.getString("viewer_login"));
}
}
return affected;
}
/** Delete the projection row when a channel FOLLOW is explicitly removed. */
public boolean deleteForUnfollowTarget(Connection c, String viewerLogin, String ownerBchName,
int rootBlockNumber) throws SQLException {
String sql = """
DELETE FROM channel_read_state crs
USING channel_names_state cns
WHERE LOWER(crs.viewer_login)=LOWER(?)
AND LOWER(crs.owner_login)=LOWER(?)
AND LOWER(cns.owner_login)=LOWER(crs.owner_login)
AND cns.slug=crs.channel_name
AND cns.channel_root_block_number=?
AND cns.channel_type_code=1
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, viewerLogin);
ps.setString(2, loginFromChainName(ownerBchName));
ps.setInt(3, rootBlockNumber);
return ps.executeUpdate() > 0;
}
}
/**
* Recomputes server-owned unread counters for all public channels owned by one logical login.
* Signed read_count/read signature fields are preserved exactly. Safe to call repeatedly after replay.
*/
public int recalculateUnreadForOwnedChannels(Connection c, String ownerLogin, long nowMs) throws SQLException {
String sql = """
WITH counts AS (
SELECT cns.owner_login, cns.slug, COUNT(b.block_number)::BIGINT AS message_count
FROM channel_names_state cns
LEFT JOIN blocks_store b
ON LOWER(b.login)=LOWER(cns.owner_login)
AND b.line_code=cns.channel_root_block_number
AND b.msg_type=1
AND b.msg_sub_type IN (10,50,100,110,120,130)
WHERE LOWER(cns.owner_login)=LOWER(?)
AND cns.channel_type_code=1
GROUP BY cns.owner_login,cns.slug
)
UPDATE channel_read_state crs
SET unread_count=GREATEST(0, counts.message_count-crs.read_count),
updated_at_ms=?
FROM counts
WHERE LOWER(crs.owner_login)=LOWER(counts.owner_login)
AND crs.channel_name=counts.slug
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, ownerLogin);
ps.setLong(2, nowMs);
return ps.executeUpdate();
}
}
private static String loginFromChainName(String bch){ if(bch==null)return null; int d=bch.lastIndexOf('-'); return d>0?bch.substring(0,d):bch; }
}
@@ -1,120 +0,0 @@
package shine.db.dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
/** Read-only поиск по серверному индексу актуальных публичных каналов. */
public final class ChannelSearchDAO {
private ChannelSearchDAO() {}
public record Match(String ownerLogin, String slug, String displayName, String description,
String avatarAr, String avatarSha256, String ownerBlockchainName,
int rootBlockNumber, String rootBlockHashHex, int subscribersCount) {}
// LIKE ESCAPE '!' — введённые пользователем %, _ и ! трактуются буквально.
private static String escapedPattern(String text) {
return text.replace("!", "!!").replace("%", "!%").replace("_", "!_");
}
private static String normalized(String text) {
return (text == null ? "" : text.trim()).toLowerCase(Locale.ROOT).replace('ё', 'е');
}
public static List<Match> search(Connection c, String query, String ownerLogin, int limit) throws SQLException {
String needle = normalized(query).replaceFirst("^@", "");
String ownerFilter = normalized(ownerLogin).replaceFirst("^@", "");
boolean ownerOnly = query != null && query.trim().startsWith("@") && !needle.contains("/");
String channelNeedle = needle;
if (needle.contains("/")) {
String[] parts = needle.split("/", 2);
if (ownerFilter.isBlank()) ownerFilter = parts[0];
channelNeedle = parts[1];
}
// Если указан owner/название, техническое и публичное название ищем только у владельца.
boolean hasOwner = !ownerFilter.isBlank();
String exact = channelNeedle;
String anywhere = "%" + escapedPattern(exact) + "%";
String prefix = escapedPattern(exact) + "%";
String ownerExact = ownerFilter;
String ownerPrefix = escapedPattern(ownerExact) + "%";
String ownerAnywhere = "%" + escapedPattern(ownerExact) + "%";
String sql = """
SELECT cn.owner_login, cn.slug, cn.display_name, cn.channel_description,
cn.ava_ar, cn.ava_sha256, cn.owner_bch_name,
cn.channel_root_block_number, encode(cn.channel_root_block_hash, 'hex') AS root_hash,
COALESCE(cs.subscribers_count, 0) AS subscribers_count
FROM channel_names_state cn
LEFT JOIN channel_stats_state cs
ON cs.owner_bch_name = cn.owner_bch_name
AND cs.channel_root_block_number = cn.channel_root_block_number
AND cs.channel_root_block_hash = cn.channel_root_block_hash
WHERE cn.channel_type_code = 1 AND NOT cn.is_deleted
AND (? = '' OR replace(lower(cn.owner_login), 'ё','е') LIKE ? ESCAPE '!')
AND (
(? = true AND replace(lower(cn.owner_login), 'ё','е') LIKE ? ESCAPE '!')
OR (? = false AND (
replace(lower(cn.display_name), 'ё','е') LIKE ? ESCAPE '!'
OR replace(lower(cn.slug), 'ё','е') LIKE ? ESCAPE '!'
OR (? = false AND replace(lower(cn.owner_login), 'ё','е') LIKE ? ESCAPE '!')
OR (? = true AND ? = '' AND replace(lower(cn.owner_login), 'ё','е') LIKE ? ESCAPE '!')
))
)
ORDER BY
CASE
WHEN replace(lower(cn.display_name), 'ё','е') = ? THEN 0
WHEN replace(lower(cn.slug), 'ё','е') = ? THEN 1
WHEN replace(lower(cn.display_name), 'ё','е') LIKE ? ESCAPE '!' THEN 2
WHEN replace(lower(cn.slug), 'ё','е') LIKE ? ESCAPE '!' THEN 3
WHEN replace(lower(cn.owner_login), 'ё','е') = ? THEN 4
WHEN replace(lower(cn.display_name), 'ё','е') LIKE ? ESCAPE '!' THEN 5
WHEN replace(lower(cn.slug), 'ё','е') LIKE ? ESCAPE '!' THEN 6
ELSE 7
END,
COALESCE(cs.subscribers_count, 0) DESC,
lower(cn.owner_login), lower(cn.slug), cn.owner_bch_name
LIMIT ?
""";
// ownerOnly = поиск @login. Когда указан владелец — ограничиваем выборку,
// а пустой сегмент / означает «все каналы этого пользователя».
String term = exact;
boolean filterByOwner = hasOwner && !ownerOnly;
List<Match> matches = new ArrayList<>();
try (PreparedStatement ps = c.prepareStatement(sql)) {
int i = 1;
ps.setString(i++, filterByOwner ? ownerFilter : "");
ps.setString(i++, ownerPrefix);
ps.setBoolean(i++, ownerOnly);
ps.setString(i++, "%" + escapedPattern(term) + "%");
ps.setBoolean(i++, ownerOnly);
ps.setString(i++, anywhere);
ps.setString(i++, anywhere);
ps.setBoolean(i++, filterByOwner);
ps.setString(i++, anywhere);
ps.setBoolean(i++, filterByOwner);
ps.setString(i++, exact);
ps.setString(i++, ownerAnywhere);
ps.setString(i++, term);
ps.setString(i++, term);
ps.setString(i++, prefix);
ps.setString(i++, prefix);
ps.setString(i++, term);
ps.setString(i++, anywhere);
ps.setString(i++, anywhere);
ps.setInt(i, Math.min(50, Math.max(1, limit)));
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) matches.add(new Match(
rs.getString("owner_login"), rs.getString("slug"), rs.getString("display_name"),
rs.getString("channel_description"), rs.getString("ava_ar"), rs.getString("ava_sha256"),
rs.getString("owner_bch_name"), rs.getInt("channel_root_block_number"),
rs.getString("root_hash"), rs.getInt("subscribers_count")
));
}
}
return matches;
}
}
@@ -39,14 +39,19 @@ public final class ConnectionsStateDAO {
*/
public List<String> listOutgoingByRelTypeCanonical(Connection c, String loginAnyCase, int relType) throws SQLException {
String sql = """
SELECT COALESCE(u_login.login, cs.to_login) AS friend_login
SELECT COALESCE(u_login.login, u_bch.login, cs.to_login) AS friend_login
FROM connections_state cs
LEFT JOIN %s
ON LOWER(u_login.login) = LOWER(cs.to_login)
LEFT JOIN %s
ON LOWER(u_bch.blockchain_name) = LOWER(cs.to_bch_name)
WHERE LOWER(cs.login) = LOWER(?)
AND cs.rel_type = ?
ORDER BY friend_login
""".formatted(CurrentUsersSql.usersSubquery("u_login"));
""".formatted(
CurrentUsersSql.usersSubquery("u_login"),
CurrentUsersSql.usersSubquery("u_bch")
);
List<String> out = new ArrayList<>();
try (PreparedStatement ps = c.prepareStatement(sql)) {
@@ -62,31 +67,6 @@ public final class ConnectionsStateDAO {
return out;
}
public boolean hasOutgoingByRelTypeCanonical(Connection c, String loginAnyCase, String peerLoginAnyCase, int relType) throws SQLException {
String sql = """
SELECT 1
FROM connections_state cs
LEFT JOIN %s
ON LOWER(u_login.login) = LOWER(cs.to_login)
WHERE LOWER(cs.login) = LOWER(?)
AND cs.rel_type = ?
AND (
LOWER(cs.to_login) = LOWER(?)
OR LOWER(COALESCE(u_login.login, cs.to_login)) = LOWER(?)
)
LIMIT 1
""".formatted(CurrentUsersSql.usersSubquery("u_login"));
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, loginAnyCase);
ps.setInt(2, relType);
ps.setString(3, peerLoginAnyCase);
ps.setString(4, peerLoginAnyCase);
try (ResultSet rs = ps.executeQuery()) {
return rs.next();
}
}
}
/**
* Incoming: список логинов (канонических), кто поставил relType пользователю login.
*/
@@ -94,12 +74,33 @@ public final class ConnectionsStateDAO {
String sql = """
SELECT COALESCE(u_actor.login, cs.login) AS friend_login
FROM connections_state cs
LEFT JOIN %s ON LOWER(u_actor.login)=LOWER(cs.login)
WHERE LOWER(cs.to_login)=LOWER(?) AND cs.rel_type=?
LEFT JOIN %s
ON LOWER(u_actor.login) = LOWER(cs.login)
LEFT JOIN %s
ON LOWER(u_target.login) = LOWER(?)
WHERE (
LOWER(cs.to_login) = LOWER(?)
OR (u_target.blockchain_name IS NOT NULL AND LOWER(cs.to_bch_name) = LOWER(u_target.blockchain_name))
)
AND cs.rel_type = ?
ORDER BY friend_login
""".formatted(CurrentUsersSql.usersSubquery("u_actor"));
List<String> out=new ArrayList<>();
try(PreparedStatement ps=c.prepareStatement(sql)){ ps.setString(1,loginAnyCase); ps.setInt(2,relType); try(ResultSet rs=ps.executeQuery()){while(rs.next()){String v=rs.getString("friend_login");if(v!=null)out.add(v);}}}
""".formatted(
CurrentUsersSql.usersSubquery("u_actor"),
CurrentUsersSql.usersSubquery("u_target")
);
List<String> out = new ArrayList<>();
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, loginAnyCase);
ps.setString(2, loginAnyCase);
ps.setInt(3, relType);
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
String v = rs.getString("friend_login");
if (v != null) out.add(v);
}
}
}
return out;
}
@@ -158,17 +159,21 @@ public final class ConnectionsStateDAO {
}
String sql = """
INSERT INTO connections_state (login, rel_type, to_login, to_block_number, to_block_hash)
VALUES (?, ?, ?, ?, ?)
ON CONFLICT(login, rel_type, to_login, to_block_number, to_block_hash) DO NOTHING
INSERT INTO connections_state (login, rel_type, to_login, to_bch_name, to_block_number, to_block_hash)
VALUES (?, ?, ?, ?, ?, ?)
ON CONFLICT(login, rel_type, to_login, to_bch_name, to_block_number, to_block_hash) DO UPDATE SET
to_bch_name=excluded.to_bch_name,
to_block_number=excluded.to_block_number,
to_block_hash=excluded.to_block_hash
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, login.trim().toLowerCase(java.util.Locale.ROOT));
ps.setString(1, login);
ps.setInt(2, relType);
ps.setString(3, toLogin.trim().toLowerCase(java.util.Locale.ROOT));
if (toBlockNumber == null) ps.setNull(4, java.sql.Types.INTEGER); else ps.setInt(4, toBlockNumber);
ps.setBytes(5, toBlockHash);
ps.setString(3, toLogin);
ps.setString(4, toBchName);
if (toBlockNumber == null) ps.setNull(5, java.sql.Types.INTEGER); else ps.setInt(5, toBlockNumber);
ps.setBytes(6, toBlockHash);
ps.executeUpdate();
}
}
@@ -204,53 +204,6 @@ public final class CurrentUsersDAO {
}
}
/** Поиск логинов и публичных имён; результат не раскрывает приватные ключи PDA. */
public record SearchUserCard(String login, String displayName, String avatarAr) {}
public List<SearchUserCard> searchDirectory(String query, Boolean isServer, int limit) throws SQLException {
String term = query.trim().toLowerCase(java.util.Locale.ROOT).replace('ё', 'е');
String escaped = term.replace("!", "!!").replace("%", "!%").replace("_", "!_");
String sql = """
SELECT su.login, coalesce(up.first_name, '') AS first_name,
coalesce(up.last_name, '') AS last_name, coalesce(up.ava_ar, '') AS ava_ar
FROM user_identity_current su
LEFT JOIN user_profile_state up ON lower(up.login) = lower(su.login)
WHERE (? IS NULL OR su.is_server = ?)
AND (
replace(lower(su.login), 'ё', 'е') LIKE ? ESCAPE '!'
OR replace(lower(coalesce(up.first_name, '') || ' ' || coalesce(up.last_name, '')), 'ё', 'е') LIKE ? ESCAPE '!'
OR replace(lower(coalesce(up.last_name, '') || ' ' || coalesce(up.first_name, '')), 'ё', 'е') LIKE ? ESCAPE '!'
)
ORDER BY
CASE WHEN replace(lower(su.login), 'ё','е') = ? THEN 0
WHEN replace(lower(su.login), 'ё','е') LIKE ? ESCAPE '!' THEN 1
WHEN replace(lower(coalesce(up.first_name, '') || ' ' || coalesce(up.last_name, '')), 'ё', 'е') LIKE ? ESCAPE '!' THEN 2
ELSE 3 END,
lower(su.login)
LIMIT ?
""";
List<SearchUserCard> users = new ArrayList<>();
try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(sql)) {
int i = 1;
if (isServer == null) { ps.setNull(i++, Types.BOOLEAN); ps.setNull(i++, Types.BOOLEAN); }
else { ps.setBoolean(i++, isServer); ps.setBoolean(i++, isServer); }
ps.setString(i++, escaped + "%");
ps.setString(i++, "%" + escaped + "%");
ps.setString(i++, "%" + escaped + "%");
ps.setString(i++, term);
ps.setString(i++, escaped + "%");
ps.setString(i++, escaped + "%");
ps.setInt(i, Math.min(50, Math.max(1, limit)));
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
String publicName = (rs.getString("first_name") + " " + rs.getString("last_name")).trim();
users.add(new SearchUserCard(rs.getString("login"), publicName, rs.getString("ava_ar")));
}
}
}
return users;
}
// -------------------- MAPPER --------------------
private CurrentUserEntry mapRow(ResultSet rs) throws SQLException {
@@ -1,518 +0,0 @@
package shine.db.dao;
import shine.db.DbController;
import shine.db.entities.DmDeliveryStateEntry;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/** Хранилище изменяемого состояния межсерверной доставки DM-пары. */
public final class DmDeliveryStateDAO {
private static volatile DmDeliveryStateDAO instance;
private final DbController db = DbController.getInstance();
private DmDeliveryStateDAO() {}
public static DmDeliveryStateDAO getInstance() {
if (instance == null) {
synchronized (DmDeliveryStateDAO.class) {
if (instance == null) instance = new DmDeliveryStateDAO();
}
}
return instance;
}
public DmDeliveryStateEntry upsertPair(
String outgoingMessageKey,
String eventId,
String baseKey,
String fromLogin,
String toLogin,
String incomingMessageKey,
long createdAtMs,
long expiresAtMs,
int initialState,
String deliveredServerLogin,
String routesHash,
boolean assistImmediately
) throws SQLException {
long now = System.currentTimeMillis();
int safeState = normalizeState(initialState, deliveredServerLogin);
if (expiresAtMs <= now && safeState == DmDeliveryStateEntry.PENDING_NONE) {
safeState = DmDeliveryStateEntry.FAILED_FINAL;
}
Long nextAttemptAt = safeState == DmDeliveryStateEntry.ACCEPTED
? now
: null;
String safeDeliveredLogin = safeState == DmDeliveryStateEntry.DELIVERED_ONE
? normalize(deliveredServerLogin)
: null;
try (Connection c = db.getConnection()) {
String sql = """
INSERT INTO dm_delivery_state (
outgoing_message_key, event_id, base_key, from_login, to_login,
incoming_message_key, created_at_ms, delivery_expires_at_ms,
delivery_state, delivered_server_login, recipient_routes_hash,
attempt_index, next_attempt_at_ms, last_attempt_at_ms, last_error, updated_at_ms
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, NULL, NULL, ?)
ON CONFLICT (outgoing_message_key) DO UPDATE SET
event_id = EXCLUDED.event_id,
base_key = EXCLUDED.base_key,
from_login = EXCLUDED.from_login,
to_login = EXCLUDED.to_login,
incoming_message_key = EXCLUDED.incoming_message_key,
created_at_ms = CASE
WHEN dm_delivery_state.event_id = EXCLUDED.event_id THEN dm_delivery_state.created_at_ms
ELSE EXCLUDED.created_at_ms
END,
delivery_expires_at_ms = CASE
WHEN dm_delivery_state.event_id = EXCLUDED.event_id THEN dm_delivery_state.delivery_expires_at_ms
ELSE EXCLUDED.delivery_expires_at_ms
END,
delivery_state = CASE
WHEN dm_delivery_state.event_id = EXCLUDED.event_id THEN dm_delivery_state.delivery_state
ELSE EXCLUDED.delivery_state
END,
delivered_server_login = CASE
WHEN dm_delivery_state.event_id = EXCLUDED.event_id THEN dm_delivery_state.delivered_server_login
ELSE EXCLUDED.delivered_server_login
END,
recipient_routes_hash = CASE
WHEN dm_delivery_state.event_id = EXCLUDED.event_id THEN COALESCE(dm_delivery_state.recipient_routes_hash, EXCLUDED.recipient_routes_hash)
ELSE EXCLUDED.recipient_routes_hash
END,
attempt_index = CASE
WHEN dm_delivery_state.event_id = EXCLUDED.event_id THEN dm_delivery_state.attempt_index
ELSE 0
END,
next_attempt_at_ms = CASE
WHEN dm_delivery_state.event_id = EXCLUDED.event_id THEN dm_delivery_state.next_attempt_at_ms
ELSE EXCLUDED.next_attempt_at_ms
END,
last_attempt_at_ms = CASE
WHEN dm_delivery_state.event_id = EXCLUDED.event_id THEN dm_delivery_state.last_attempt_at_ms
ELSE NULL
END,
last_error = CASE
WHEN dm_delivery_state.event_id = EXCLUDED.event_id THEN dm_delivery_state.last_error
ELSE NULL
END,
updated_at_ms = EXCLUDED.updated_at_ms
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, outgoingMessageKey);
ps.setString(2, eventId);
ps.setString(3, baseKey);
ps.setString(4, normalize(fromLogin));
ps.setString(5, normalize(toLogin));
ps.setString(6, incomingMessageKey);
ps.setLong(7, createdAtMs);
ps.setLong(8, expiresAtMs);
ps.setInt(9, safeState);
setNullableString(ps, 10, safeDeliveredLogin);
setNullableString(ps, 11, normalizeBlank(routesHash));
setNullableLong(ps, 12, nextAttemptAt);
ps.setLong(13, now);
ps.executeUpdate();
}
}
DmDeliveryStateEntry result;
if (initialState != DmDeliveryStateEntry.PENDING_NONE || !isBlank(deliveredServerLogin)) {
result = mergeRemote(eventId, initialState, deliveredServerLogin, routesHash, now);
} else {
result = getByEventId(eventId);
}
if (result != null && result.getDeliveryExpiresAtMs() <= now
&& result.getDeliveryState() == DmDeliveryStateEntry.PENDING_NONE) {
return finishAtExpiry(eventId, now);
}
return result;
}
public DmDeliveryStateEntry getByEventId(String eventId) throws SQLException {
if (isBlank(eventId)) return null;
try (Connection c = db.getConnection();
PreparedStatement ps = c.prepareStatement(selectColumns() + " WHERE event_id = ?")) {
ps.setString(1, eventId.trim());
try (ResultSet rs = ps.executeQuery()) {
return rs.next() ? mapRow(rs) : null;
}
}
}
public DmDeliveryStateEntry getByOutgoingMessageKey(String outgoingMessageKey) throws SQLException {
if (isBlank(outgoingMessageKey)) return null;
try (Connection c = db.getConnection();
PreparedStatement ps = c.prepareStatement(selectColumns() + " WHERE outgoing_message_key = ?")) {
ps.setString(1, outgoingMessageKey.trim());
try (ResultSet rs = ps.executeQuery()) {
return rs.next() ? mapRow(rs) : null;
}
}
}
public Map<String, DmDeliveryStateEntry> listByOutgoingMessageKeys(List<String> keys) throws SQLException {
Map<String, DmDeliveryStateEntry> out = new HashMap<>();
if (keys == null || keys.isEmpty()) return out;
String placeholders = String.join(",", java.util.Collections.nCopies(keys.size(), "?"));
String sql = selectColumns() + " WHERE outgoing_message_key IN (" + placeholders + ")";
try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(sql)) {
for (int i = 0; i < keys.size(); i++) ps.setString(i + 1, keys.get(i));
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
DmDeliveryStateEntry row = mapRow(rs);
out.put(row.getOutgoingMessageKey(), row);
}
}
}
return out;
}
public List<DmDeliveryStateEntry> listDue(long nowMs, int limit) throws SQLException {
String sql = selectColumns() + """
WHERE delivery_state = 0
AND next_attempt_at_ms IS NOT NULL
AND next_attempt_at_ms <= ?
ORDER BY next_attempt_at_ms ASC, created_at_ms ASC
LIMIT ?
""";
List<DmDeliveryStateEntry> out = new ArrayList<>();
try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(sql)) {
ps.setLong(1, nowMs);
ps.setInt(2, Math.max(1, limit));
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) out.add(mapRow(rs));
}
}
return out;
}
public boolean claimAttempt(DmDeliveryStateEntry row, long nowMs, Long nextAttemptAtMs) throws SQLException {
String sql = """
UPDATE dm_delivery_state
SET attempt_index = attempt_index + 1,
next_attempt_at_ms = ?,
last_attempt_at_ms = ?,
last_error = NULL,
updated_at_ms = ?
WHERE outgoing_message_key = ?
AND event_id = ?
AND attempt_index = ?
AND delivery_state = 0
AND next_attempt_at_ms IS NOT NULL
AND next_attempt_at_ms <= ?
""";
try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(sql)) {
long networkLeaseUntilMs = nowMs + 60_000L;
Long claimedNextAttemptAtMs = nextAttemptAtMs == null
? networkLeaseUntilMs
: Math.max(nextAttemptAtMs, networkLeaseUntilMs);
setNullableLong(ps, 1, claimedNextAttemptAtMs);
ps.setLong(2, nowMs);
ps.setLong(3, nowMs);
ps.setString(4, row.getOutgoingMessageKey());
ps.setString(5, row.getEventId());
ps.setInt(6, row.getAttemptIndex());
ps.setLong(7, nowMs);
return ps.executeUpdate() == 1;
}
}
public DmDeliveryStateEntry mergeRemote(
String eventId,
int remoteState,
String remoteDeliveredLogin,
String remoteRoutesHash,
long nowMs
) throws SQLException {
try (Connection c = db.getConnection()) {
boolean previousAutoCommit = c.getAutoCommit();
c.setAutoCommit(false);
try {
DmDeliveryStateEntry current = getByEventIdForUpdate(c, eventId);
if (current == null) {
c.rollback();
return null;
}
MergeResult merged = merge(
current.getDeliveryState(),
current.getDeliveredServerLogin(),
current.getRecipientRoutesHash(),
remoteState,
remoteDeliveredLogin,
remoteRoutesHash
);
updateMutableState(c, current, merged.state(), merged.deliveredLogin(),
merged.routesHash(), current.getNextAttemptAtMs(), current.getLastError(), nowMs);
c.commit();
return getByEventId(eventId);
} catch (Exception e) {
try { c.rollback(); } catch (Exception ignored) {}
throw e;
} finally {
c.setAutoCommit(previousAutoCommit);
}
}
}
public DmDeliveryStateEntry updateAfterAttempt(
String eventId,
int attemptedState,
String deliveredServerLogin,
String routesHash,
Long nextAttemptAtMs,
String lastError,
long nowMs
) throws SQLException {
try (Connection c = db.getConnection()) {
boolean previousAutoCommit = c.getAutoCommit();
c.setAutoCommit(false);
try {
DmDeliveryStateEntry current = getByEventIdForUpdate(c, eventId);
if (current == null) {
c.rollback();
return null;
}
MergeResult merged = merge(
current.getDeliveryState(), current.getDeliveredServerLogin(), current.getRecipientRoutesHash(),
attemptedState, deliveredServerLogin, routesHash
);
Long effectiveNext = merged.state() == DmDeliveryStateEntry.ACCEPTED
? nextAttemptAtMs
: null;
updateMutableState(c, current, merged.state(), merged.deliveredLogin(),
merged.routesHash(), effectiveNext, lastError, nowMs);
c.commit();
return getByEventId(eventId);
} catch (Exception e) {
try { c.rollback(); } catch (Exception ignored) {}
throw e;
} finally {
c.setAutoCommit(previousAutoCommit);
}
}
}
public DmDeliveryStateEntry finishAtExpiry(String eventId, long nowMs) throws SQLException {
try (Connection c = db.getConnection()) {
String sql = """
UPDATE dm_delivery_state
SET delivery_state = CASE WHEN delivery_state = 0 THEN 3 ELSE delivery_state END,
delivered_server_login = CASE WHEN delivery_state = 0 THEN NULL ELSE delivered_server_login END,
next_attempt_at_ms = NULL,
last_error = CASE WHEN delivery_state = 0 THEN 'DELIVERY_EXPIRED' ELSE last_error END,
updated_at_ms = ?
WHERE event_id = ? AND delivery_state = 0
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setLong(1, nowMs);
ps.setString(2, eventId);
ps.executeUpdate();
}
}
return getByEventId(eventId);
}
/** Read-only peer confirmed that at least one recipient server accepted the message. */
public DmDeliveryStateEntry markDeliveredFromPeer(String eventId, long nowMs) throws SQLException {
try (Connection c = db.getConnection();
PreparedStatement ps = c.prepareStatement("""
UPDATE dm_delivery_state
SET delivery_state = 1,
delivered_server_login = NULL,
next_attempt_at_ms = NULL,
last_error = NULL,
updated_at_ms = ?
WHERE event_id = ? AND delivery_state = 0
""")) {
ps.setLong(1, nowMs);
ps.setString(2, eventId);
ps.executeUpdate();
}
return getByEventId(eventId);
}
public int removeByBaseKey(String baseKey) throws SQLException {
try (Connection c = db.getConnection();
PreparedStatement ps = c.prepareStatement("DELETE FROM dm_delivery_state WHERE base_key = ?")) {
ps.setString(1, baseKey);
return ps.executeUpdate();
}
}
public int removeConversationBefore(String fromLogin, String toLogin, long boundaryTimeMs) throws SQLException {
String sql = """
DELETE FROM dm_delivery_state
WHERE created_at_ms < ?
AND ((LOWER(from_login) = LOWER(?) AND LOWER(to_login) = LOWER(?))
OR (LOWER(from_login) = LOWER(?) AND LOWER(to_login) = LOWER(?)))
""";
try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(sql)) {
ps.setLong(1, boundaryTimeMs);
ps.setString(2, fromLogin);
ps.setString(3, toLogin);
ps.setString(4, toLogin);
ps.setString(5, fromLogin);
return ps.executeUpdate();
}
}
public int removeMissingMessages() throws SQLException {
String sql = """
DELETE FROM dm_delivery_state d
WHERE NOT EXISTS (
SELECT 1 FROM signed_messages m WHERE m.message_key = d.outgoing_message_key
)
""";
try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(sql)) {
return ps.executeUpdate();
}
}
private DmDeliveryStateEntry getByEventIdForUpdate(Connection c, String eventId) throws SQLException {
try (PreparedStatement ps = c.prepareStatement(selectColumns() + " WHERE event_id = ? FOR UPDATE")) {
ps.setString(1, eventId);
try (ResultSet rs = ps.executeQuery()) {
return rs.next() ? mapRow(rs) : null;
}
}
}
private void updateMutableState(
Connection c,
DmDeliveryStateEntry current,
int state,
String deliveredLogin,
String routesHash,
Long nextAttemptAtMs,
String lastError,
long nowMs
) throws SQLException {
String sql = """
UPDATE dm_delivery_state
SET delivery_state = ?,
delivered_server_login = ?,
recipient_routes_hash = ?,
next_attempt_at_ms = ?,
last_error = ?,
updated_at_ms = ?
WHERE outgoing_message_key = ? AND event_id = ?
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setInt(1, state);
setNullableString(ps, 2, state == DmDeliveryStateEntry.DELIVERED_ONE ? normalize(deliveredLogin) : null);
setNullableString(ps, 3, normalizeBlank(routesHash));
setNullableLong(ps, 4, nextAttemptAtMs);
setNullableString(ps, 5, normalizeBlank(lastError));
ps.setLong(6, nowMs);
ps.setString(7, current.getOutgoingMessageKey());
ps.setString(8, current.getEventId());
ps.executeUpdate();
}
}
private MergeResult merge(
int localState,
String localLogin,
String localHash,
int remoteStateRaw,
String remoteLoginRaw,
String remoteHashRaw
) {
int remoteState = normalizeState(remoteStateRaw, remoteLoginRaw);
String remoteLogin = normalize(remoteLoginRaw);
String localNormalizedLogin = normalize(localLogin);
String localRoutesHash = normalizeBlank(localHash);
String remoteRoutesHash = normalizeBlank(remoteHashRaw);
String resultHash = remoteRoutesHash != null ? remoteRoutesHash : localRoutesHash;
if (localState == DmDeliveryStateEntry.DELIVERED_ONE || localState == DmDeliveryStateEntry.DELIVERED_ALL) {
return new MergeResult(DmDeliveryStateEntry.DELIVERED, localNormalizedLogin,
localRoutesHash != null ? localRoutesHash : remoteRoutesHash);
}
if (remoteState == DmDeliveryStateEntry.DELIVERED_ONE || remoteState == DmDeliveryStateEntry.DELIVERED_ALL) {
return new MergeResult(DmDeliveryStateEntry.DELIVERED, remoteLogin, resultHash);
}
if (localState == DmDeliveryStateEntry.FAILED_FINAL || remoteState == DmDeliveryStateEntry.FAILED_FINAL) {
return new MergeResult(DmDeliveryStateEntry.FAILED_FINAL, null, resultHash);
}
return new MergeResult(DmDeliveryStateEntry.PENDING_NONE, null, resultHash);
}
private int normalizeState(int state, String deliveredLogin) {
if (state < DmDeliveryStateEntry.PENDING_NONE || state > DmDeliveryStateEntry.FAILED_FINAL) {
return DmDeliveryStateEntry.PENDING_NONE;
}
if (state == DmDeliveryStateEntry.DELIVERED_ALL) return DmDeliveryStateEntry.DELIVERED;
return state;
}
private String selectColumns() {
return """
SELECT outgoing_message_key, event_id, base_key, from_login, to_login,
incoming_message_key, created_at_ms, delivery_expires_at_ms,
delivery_state, delivered_server_login, recipient_routes_hash,
attempt_index, next_attempt_at_ms, last_attempt_at_ms, last_error, updated_at_ms
FROM dm_delivery_state
""";
}
private DmDeliveryStateEntry mapRow(ResultSet rs) throws SQLException {
DmDeliveryStateEntry e = new DmDeliveryStateEntry();
e.setOutgoingMessageKey(rs.getString("outgoing_message_key"));
e.setEventId(rs.getString("event_id"));
e.setBaseKey(rs.getString("base_key"));
e.setFromLogin(rs.getString("from_login"));
e.setToLogin(rs.getString("to_login"));
e.setIncomingMessageKey(rs.getString("incoming_message_key"));
e.setCreatedAtMs(rs.getLong("created_at_ms"));
e.setDeliveryExpiresAtMs(rs.getLong("delivery_expires_at_ms"));
e.setDeliveryState(rs.getInt("delivery_state"));
e.setDeliveredServerLogin(rs.getString("delivered_server_login"));
e.setRecipientRoutesHash(rs.getString("recipient_routes_hash"));
e.setAttemptIndex(rs.getInt("attempt_index"));
long next = rs.getLong("next_attempt_at_ms");
e.setNextAttemptAtMs(rs.wasNull() ? null : next);
long last = rs.getLong("last_attempt_at_ms");
e.setLastAttemptAtMs(rs.wasNull() ? null : last);
e.setLastError(rs.getString("last_error"));
e.setUpdatedAtMs(rs.getLong("updated_at_ms"));
return e;
}
private static void setNullableString(PreparedStatement ps, int index, String value) throws SQLException {
if (isBlank(value)) ps.setNull(index, Types.VARCHAR);
else ps.setString(index, value.trim());
}
private static void setNullableLong(PreparedStatement ps, int index, Long value) throws SQLException {
if (value == null) ps.setNull(index, Types.BIGINT);
else ps.setLong(index, value);
}
private static String normalize(String value) {
if (value == null) return null;
String normalized = value.trim().toLowerCase();
return normalized.isEmpty() ? null : normalized;
}
private static String normalizeBlank(String value) {
if (value == null) return null;
String normalized = value.trim();
return normalized.isEmpty() ? null : normalized;
}
private static boolean isBlank(String value) {
return value == null || value.isBlank();
}
private record MergeResult(int state, String deliveredLogin, String routesHash) {}
}

Some files were not shown because too many files have changed in this diff Show More