diff --git a/-- удалить javac.20260920_155256.args b/-- удалить javac.20260920_155256.args deleted file mode 100644 index 5d0cf8ff..00000000 --- a/-- удалить javac.20260920_155256.args +++ /dev/null @@ -1,30 +0,0 @@ --proc:none --d -/tmp/javac-check --sourcepath -SHiNE-server/shine-server-geo/src/main/java:SHiNE-server/shine-server-log/src/main/java:SHiNE-server/shine-server-solana-users-sync/src/main/java:SHiNE-server/shine-server-db/src/main/java:SHiNE-server/src/main/java:SHiNE-server/shine-server-archive/src/main/java:SHiNE-server/shine-server-blockchain/src/main/java:SHiNE-server/shine-server-crypto/src/main/java:SHiNE-server/shine-server-net-protocol/src/main/java:SHiNE-server/shine-server-config/src/main/java -/mnt/data/shine_patch_final_work/SHiNE-server/shine-server-net-protocol/src/main/java/server/sync/BlockchainResyncGuard.java -/mnt/data/shine_patch_final_work/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/JsonHandlerRegistry.java -/mnt/data/shine_patch_final_work/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_AddBlock_Handler.java -/mnt/data/shine_patch_final_work/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_AddBlock_Handler_utils/BlockchainWriter.java -/mnt/data/shine_patch_final_work/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/Ans104DataItem.java -/mnt/data/shine_patch_final_work/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/BchCryptoVerifier.java -/mnt/data/shine_patch_final_work/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/BchBlockEntry.java -/mnt/data/shine_patch_final_work/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlocksConfig.java -/mnt/data/shine_patch_final_work/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncScheduler.java -/mnt/data/shine_patch_final_work/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveMerkle.java -/mnt/data/shine_patch_final_work/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncService.java -/mnt/data/shine_patch_final_work/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockPublisherScheduler.java -/mnt/data/shine_patch_final_work/SHiNE-server/shine-server-archive/src/main/java/server/archive/Ans104Bundle.java -/mnt/data/shine_patch_final_work/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveL1Uploader.java -/mnt/data/shine_patch_final_work/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockPublisherService.java -/mnt/data/shine_patch_final_work/SHiNE-server/src/main/java/server/ws/WsServer.java -/mnt/data/shine_patch_final_work/SHiNE-server/src/main/java/server/sync/PeriodicBlockchainSyncService.java -/mnt/data/shine_patch_final_work/SHiNE-server/src/test/java/test/it/blockchain/AddBlockSender.java -/mnt/data/shine_patch_final_work/SHiNE-server/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java -/mnt/data/shine_patch_final_work/SHiNE-server/shine-server-db/src/main/java/shine/db/entities/BlockEntry.java -/mnt/data/shine_patch_final_work/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ArweaveBlockImportDAO.java -/mnt/data/shine_patch_final_work/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlockchainResyncCleanupDAO.java -/mnt/data/shine_patch_final_work/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlocksDAO.java -/mnt/data/shine_patch_final_work/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ChannelNameStateDAO.java -/mnt/data/shine_patch_final_work/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/SolanaUserPdaCurrentDAO.java diff --git a/.gitignore b/.gitignore index 34986288..b92b1a5d 100644 --- a/.gitignore +++ b/.gitignore @@ -78,6 +78,7 @@ shine-solana/shine/scripts/**/TEMP_*.md # Локальные артефакты и внешние материалы ESP32-подпроекта ESP32/esp32-config-tool/ +ESP32/local-sketches/ ESP32/**/.git/ ESP32/**/.idea/ ESP32-wallet/.idea/ diff --git a/AGENTS.md b/AGENTS.md index 967fed5a..24b14b0f 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -138,11 +138,8 @@ - с какого сценария продолжать разработку; - из какого коммита брать последнюю полную реализацию. -## Коммуникация по новым задачам (обязательно) -- При получении нового задания сначала кратко пересказать задачу своими словами. -- До начала реализации задать недостающие уточняющие вопросы (если они есть). +## Коммуникация по новым задачам +- При получении нового задания кратко подтвердить понимание задачи, если это помогает синхронизироваться. +- До начала реализации задавать уточняющие вопросы только когда без ответа есть риск сделать не то или затронуть опасную область. +- Если задача понятна и не требует отдельного подтверждения по другим правилам проекта, переходить к реализации сразу. - Если есть уместные идеи/улучшения — кратко предложить их; если полезных идей нет, ничего дополнительно не предлагать. -- Добавлять краткую оценку фичи (насколько это полезно/удачно по мнению исполнителя). -- После этого обязательно запросить подтверждение от пользователя, что задача понята верно, и только после подтверждения переходить к реализации. -- Если вопросов нет, явно написать в формате: «Я всё понял, начинаю делать?» и ждать подтверждения. -- Без подтверждения пользователя реализацию не начинать. diff --git a/ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/main-device/burn.sh b/ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/main-device/burn.sh index 494bcba5..62a2b933 100755 --- a/ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/main-device/burn.sh +++ b/ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/main-device/burn.sh @@ -47,10 +47,13 @@ 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-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" >&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-screen-start-stub" >&2 exit 2 ;; esac @@ -78,6 +81,7 @@ 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}" ) diff --git a/ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/main-device/test_sketches/README.md b/ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/main-device/test_sketches/README.md index 782eb846..4b5364a3 100644 --- a/ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/main-device/test_sketches/README.md +++ b/ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/main-device/test_sketches/README.md @@ -15,6 +15,8 @@ - `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 - `lvgl_nav_minimal_test/` - старое тестовое имя, этот скетч перенесён в `shine_homeserver_main/` и теперь является основным ## Запуск @@ -29,3 +31,5 @@ - `./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` diff --git a/ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/main-device/test_sketches/usb_contact_screen_start_stub/usb_contact_screen_start_stub.ino b/ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/main-device/test_sketches/usb_contact_screen_start_stub/usb_contact_screen_start_stub.ino new file mode 100644 index 00000000..59d74ac3 --- /dev/null +++ b/ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/main-device/test_sketches/usb_contact_screen_start_stub/usb_contact_screen_start_stub.ino @@ -0,0 +1,600 @@ +#include +#include +#include +#include +#include +#include +#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(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(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); +} diff --git a/ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/main-device/test_sketches/usb_contact_sensor_debug_test/usb_contact_sensor_debug_test.ino b/ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/main-device/test_sketches/usb_contact_sensor_debug_test/usb_contact_sensor_debug_test.ino new file mode 100644 index 00000000..1901a7cb --- /dev/null +++ b/ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/main-device/test_sketches/usb_contact_sensor_debug_test/usb_contact_sensor_debug_test.ino @@ -0,0 +1,407 @@ +#include +#include +#include +#include +#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); +} diff --git a/ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/main-device/test_sketches/usb_contact_sensor_test/usb_contact_sensor_test.ino b/ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/main-device/test_sketches/usb_contact_sensor_test/usb_contact_sensor_test.ino new file mode 100644 index 00000000..de55d2f8 --- /dev/null +++ b/ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/main-device/test_sketches/usb_contact_sensor_test/usb_contact_sensor_test.ino @@ -0,0 +1,250 @@ +#include +#include +#include +#include +#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); +} diff --git a/ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/reference/usb_contact_sensor_test_spec.md b/ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/reference/usb_contact_sensor_test_spec.md new file mode 100644 index 00000000..1bf50631 --- /dev/null +++ b/ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/reference/usb_contact_sensor_test_spec.md @@ -0,0 +1,88 @@ +# 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/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. + +## 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. diff --git a/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockPublisherScheduler.java b/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockPublisherScheduler.java index 4025ff08..b2fba9d9 100644 --- a/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockPublisherScheduler.java +++ b/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockPublisherScheduler.java @@ -2,17 +2,32 @@ 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; -/** Fixed-delay publisher. Empty cycles are no-ops. */ +/** + * 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 IMMEDIATE_QUEUE = new ConcurrentLinkedQueue<>(); + private static final ConcurrentHashMap PENDING_SINCE_MS = new ConcurrentHashMap<>(); + private static ScheduledExecutorService executor; + private static ArweaveBlockPublisherService service; + private static ArweaveBlocksConfig config; private ArweaveBlockPublisherScheduler() {} @@ -23,15 +38,105 @@ public final class ArweaveBlockPublisherScheduler { if (!cfg.publishEnabled()) { log.info("Arweave user-block publisher disabled (mode=none)"); return; } if (!STARTED.compareAndSet(false,true)) return; try { - ArweaveBlockPublisherService service = new ArweaveBlockPublisherService(cfg); + config = cfg; + service = new ArweaveBlockPublisherService(cfg); executor = Executors.newSingleThreadScheduledExecutor(r -> { Thread t = new Thread(r, "shine-arweave-block-publisher"); t.setDaemon(true); return t; }); - Runnable task = () -> { try { service.runCycle(); } catch (Exception e) { log.error("Arweave block publish cycle failed", e); } }; - executor.scheduleWithFixedDelay(task, 0, cfg.publishIntervalMinutes(), TimeUnit.MINUTES); - log.info("Arweave user-block publisher enabled: mode={} interval={}m", cfg.publishMode(), cfg.publishIntervalMinutes()); - } catch (Exception e) { STARTED.set(false); log.error("Arweave user-block publisher failed to start", e); } + + 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); + } } - public static void close() { ScheduledExecutorService e=executor; if(e!=null)e.shutdownNow(); } + 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(); + } } diff --git a/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockPublisherService.java b/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockPublisherService.java index 4b979459..df48e67e 100644 --- a/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockPublisherService.java +++ b/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockPublisherService.java @@ -3,10 +3,15 @@ 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 { @@ -14,6 +19,7 @@ public final class ArweaveBlockPublisherService { private final ArweaveBlocksConfig cfg; private final BlocksDAO blocksDAO = BlocksDAO.getInstance(); + private final KeyRotationCandidateBlocksDAO candidateBlocksDAO = KeyRotationCandidateBlocksDAO.getInstance(); private final ArweaveL1Uploader arweaveUploader; private final TurboDataItemUploader turboUploader; @@ -23,18 +29,105 @@ public final class ArweaveBlockPublisherService { 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 eligible, Consumer onPublished) throws Exception { + return runCycle(eligible == null ? id -> true : eligible, onPublished == null ? id -> {} : onPublished); + } + + private int runCycle(Predicate eligible, Consumer onPublished) throws Exception { if (cfg.publishMode() == ArweaveBlocksConfig.PublishMode.NONE) return 0; - List candidates = blocksDAO.listPendingArweave(cfg.publishMaxItems()); - if (candidates.isEmpty()) return 0; - return switch (cfg.publishMode()) { - case TURBO -> publishTurbo(candidates); + + int maxItems = cfg.publishMaxItems(); + int attempted = 0; + int published = 0; + + // Ротация приоритетна: пользователь уже заблокирован для обычной записи и ждёт завершения копирования. + List 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 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 publishTurbo(List candidates) throws Exception { + private int publishTurboRotation(List candidates, Consumer 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 candidates, Consumer onPublished) throws Exception { int published = 0; Exception firstFailure = null; for (BlockEntry e : candidates) { @@ -44,6 +137,7 @@ public final class ArweaveBlockPublisherService { 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) { @@ -57,6 +151,40 @@ public final class ArweaveBlockPublisherService { return published; } + private int publishDirectArweaveRotation(List candidates) throws Exception { + List items = new ArrayList<>(); + List 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 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 candidates) throws Exception { List items = new ArrayList<>(); List ids = new ArrayList<>(); diff --git a/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncScheduler.java b/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncScheduler.java index b5c1369b..233a9ccd 100644 --- a/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncScheduler.java +++ b/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncScheduler.java @@ -22,10 +22,14 @@ public final class ArweaveBlockSyncScheduler { 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); - log.info("Arweave user-block sync enabled: interval={}m gateway={}",cfg.syncIntervalMinutes(),cfg.syncGateway()); + 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();} diff --git a/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncService.java b/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncService.java index 2c249d29..d43253be 100644 --- a/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncService.java +++ b/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncService.java @@ -7,9 +7,15 @@ 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 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; @@ -22,11 +28,15 @@ 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=test5590 DataItems and imports the exact signed ANS-104 bytes. + * Discovers individual App=test5591 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. */ @@ -45,14 +55,28 @@ public final class ArweaveBlockSyncService { 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 unresolvedDownloads = new LinkedHashMap<>(); public ArweaveBlockSyncService(ArweaveBlocksConfig cfg) { this.cfg = cfg; } public void runCycle() throws Exception { + recoverInterruptedCanonicalRebuilds(); discover(); 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); @@ -85,11 +109,20 @@ public final class ArweaveBlockSyncService { log.warn("Ignoring malformed Arweave DataItem id {}: {}", dataItemId, e.getMessage()); continue; } - if (blocksDAO.existsByDataItemId(id32) || importDAO.exists(id32)) continue; + if (blocksDAO.existsByDataItemId(id32) || importDAO.exists(id32)) { + unresolvedDownloads.remove(dataItemId); + continue; + } try { - byte[] rawDataItem = downloadSignedDataItem(dataItemId); - if (importDAO.enqueueIfMissing(id32, height, rawDataItem, System.currentTimeMillis())) discovered++; + DownloadedDataItem downloaded = downloadSignedDataItem(dataItemId); + 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()); @@ -108,37 +141,117 @@ public final class ArweaveBlockSyncService { } } + private int retryPendingDownloads() throws Exception { + if (unresolvedDownloads.isEmpty()) return 0; + + int queued = 0; + int attempted = 0; + List 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 (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 replayedLogins = new HashSet<>(); do { progress = false; - List pending = importDAO.listPending(cfg.syncQueueBatchSize()); + + // 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 pending = importDAO.listPendingValidated(cfg.syncQueueBatchSize()); if (pending.isEmpty()) break; for (ArweaveBlockImportDAO.QueueItem q : pending) { - Ans104DataItem item; - try { - item = new Ans104DataItem(q.rawDataItem()); - if (!Arrays.equals(item.id32(), q.dataItemId())) 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"); - new BchBlockEntry(q.rawDataItem()); - } catch (Exception e) { - importDAO.reject(q.dataItemId(), "invalid_data_item: " + e.getMessage(), System.currentTimeMillis()); + 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; } - SolanaUserPdaCurrentEntry user = usersDAO.getByBlockchainKey(item.owner32()); - if (user == null || user.getBlockchainName() == null || user.getBlockchainName().isBlank()) { - importDAO.setPendingError(q.dataItemId(), "unknown_owner", System.currentTimeMillis()); + 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; } - ensureState(user); - Net_AddBlock_Handler.ArweaveImportResult result = addBlock.addBlockFromArweave(user.getBlockchainName(), q.rawDataItem()); + + 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++; progress = true; + importedTotal++; + replayedLogins.add(q.parsedLogin()); + progress = true; + rebuildIfLocalOrphansExist(q.parsedLogin(), activeFork); continue; } String reason = result.reasonCode(); @@ -148,21 +261,217 @@ public final class ArweaveBlockSyncService { importDAO.setPendingError(q.dataItemId(), reason, System.currentTimeMillis()); } else { importDAO.reject(q.dataItemId(), reason, System.currentTimeMillis()); + progress = true; } } passes++; - } while (progress && passes < 8); + } 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); } - private void ensureState(SolanaUserPdaCurrentEntry user) throws Exception { - BlockchainStateEntry existing = stateDAO.getByBlockchainName(user.getBlockchainName()); - if (existing != null) return; - 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); s.setLastBlockNumber(-1); s.setLastBlockHash(null); s.setUpdatedAtMs(System.currentTimeMillis()); - stateDAO.insertIfMissing(s); + /** + * 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 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 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);} } private JsonNode graphQlPage(long minHeight, String cursor) throws Exception { @@ -181,53 +490,186 @@ public final class ArweaveBlockSyncService { } /** - * Gateways normally expose only the payload at /{dataItemId}. SHiNE needs the complete signed - * DataItem, so obtain its exact offset/size inside the root L1 transaction and range-read it. + * Gateway по /{dataItemId} обычно отдаёт только payload. Для импорта SHiNE нужен полный + * подписанный ANS-104 DataItem, поэтому сначала резолвим rootTx + offset + size, а затем + * читаем точный range из root L1 transaction. */ - private byte[] downloadSignedDataItem(String dataItemId) throws Exception { - JsonNode offsets = getOffsets(dataItemId); - String rootTxId = offsets.path("rootTxId").asText("").trim(); - long rootOffset = offsets.path("rootOffset").asLong(-1L); - long size = offsets.path("size").asLong(-1L); - if (rootTxId.isBlank() || rootOffset < 0 || size <= 0) { - throw new IOException("Bad AR.IO offsets for " + dataItemId + ": " + offsets); - } - if (size > cfg.syncMaxDataItemBytes()) { - throw new IOException("DataItem exceeds syncMaxDataItemBytes: " + size); - } - if (rootOffset > Long.MAX_VALUE - size) throw new IOException("DataItem offset overflow"); - long endInclusive = rootOffset + size - 1; + 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/" + rootTxId)) + HttpRequest req = HttpRequest.newBuilder(URI.create(trim(cfg.syncGateway()) + "/raw/" + location.rootTxId())) .timeout(Duration.ofMinutes(2)) - .header("Range", "bytes=" + rootOffset + "-" + endInclusive) + .header("Range", "bytes=" + location.rootOffset() + "-" + endInclusive) .header("Accept", "application/octet-stream") .GET().build(); HttpResponse 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, (int) size); - if (bytes.length != size) throw new IOException("Truncated DataItem range: expected=" + size + " got=" + bytes.length); + 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 bytes; + return new DownloadedDataItem(location.rootTxId(), bytes); } } - private JsonNode getOffsets(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 resp = http.send(req, HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8)); - if (resp.statusCode() == 404) throw new IOException("AR.IO offsets not indexed yet"); - if (resp.statusCode() < 200 || resp.statusCode() >= 300) { - throw new IOException("AR.IO offsets HTTP " + resp.statusCode() + ": " + safe(resp.body())); + /** + * Координаты считаются только подсказкой транспорта: источник может ошибиться, поэтому после + * range-read всё равно обязательно сверяется настоящий ANS-104 DataItem ID и затем подпись. + */ + private DataItemLocation resolveDataItemLocation(String dataItemId) throws Exception { + List 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)); } - return MAPPER.readTree(resp.body()); + + 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 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 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 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 { diff --git a/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlocksConfig.java b/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlocksConfig.java index f97790c6..71d82f2e 100644 --- a/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlocksConfig.java +++ b/SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlocksConfig.java @@ -1,6 +1,7 @@ package server.archive; import blockchain.Ans104DataItem; +import blockchain.ShineProtocolTags; import utils.config.AppConfig; import java.nio.file.Path; @@ -26,7 +27,9 @@ public record ArweaveBlocksConfig( int syncQueueBatchSize, long syncStartBlockHeight, long syncMaxDataItemBytes, - String syncGateway + String syncGateway, + String syncTurboApiBase, + int syncLocationRetrySeconds ) { public enum PublishMode { TURBO, @@ -45,9 +48,9 @@ public record ArweaveBlocksConfig( } } - public static final String TEST_TAG_NAME = "App"; - public static final String TEST_TAG_VALUE = "test5590"; - public static final String CHANNEL_TAG_NAME = "c_test5590"; + 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(); @@ -72,7 +75,9 @@ public record ArweaveBlocksConfig( 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.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") ); } diff --git a/SHiNE-server/shine-server-archive/src/test/java/server/archive/Ans104BundleTest.java b/SHiNE-server/shine-server-archive/src/test/java/server/archive/Ans104BundleTest.java index 2b83e9e1..567cfb68 100644 --- a/SHiNE-server/shine-server-archive/src/test/java/server/archive/Ans104BundleTest.java +++ b/SHiNE-server/shine-server-archive/src/test/java/server/archive/Ans104BundleTest.java @@ -29,7 +29,7 @@ final class Ans104BundleTest { byte[] privateKey = Ed25519Util.generatePrivateKeyFromString("bundle-" + payload); byte[] owner = Ed25519Util.derivePublicKey(privateKey); byte[] data = payload.getBytes(StandardCharsets.UTF_8); - List tags = List.of(new Ans104DataItem.Tag("App", "test5590")); + List 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); } diff --git a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/BchBlockEntry.java b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/BchBlockEntry.java index 2e6d77be..a113dc25 100644 --- a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/BchBlockEntry.java +++ b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/BchBlockEntry.java @@ -17,6 +17,7 @@ import java.util.Objects; * 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 @@ -33,10 +34,11 @@ public final class BchBlockEntry { 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 + 4 + 4 + 8 + 2 + 2 + 2; + 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 final long timestamp; @@ -66,6 +68,8 @@ public final class BchBlockEntry { } this.prevHash32 = new byte[32]; bb.get(prevHash32); + this.back32Hash32 = new byte[32]; + bb.get(back32Hash32); this.blockSize = bb.getInt(); if (blockSize != frameBytes.length || blockSize < FRAME_HEADER_SIZE) { throw new IllegalArgumentException("SHiNE blockSize mismatch: declared=" + blockSize + " actual=" + frameBytes.length); diff --git a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/BodyRecordParser.java b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/BodyRecordParser.java index 35cf71b0..98fdb185 100644 --- a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/BodyRecordParser.java +++ b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/BodyRecordParser.java @@ -25,6 +25,10 @@ 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) ); @@ -33,7 +37,7 @@ public final class BodyRecordParser { int key = (t << 16) | v; BodyRecord r = switch (key) { - case TextBody.KEY -> { + case TextLineBody.KEY -> { if (st == (MsgSubType.TEXT_POST & 0xFFFF) || st == (MsgSubType.TEXT_EDIT_POST & 0xFFFF) || st == (MsgSubType.TEXT_EXERCISE & 0xFFFF) @@ -41,7 +45,8 @@ 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_META & 0xFFFF) + || st == (MsgSubType.TEXT_CHANNEL_DELETE & 0xFFFF)) { yield new TextLineBody(subType, version, bodyBytes); } diff --git a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/LineIndex.java b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/LineIndex.java index 0638b42b..7451eecd 100644 --- a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/LineIndex.java +++ b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/LineIndex.java @@ -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_PARAM = 4; // параметры профиля да надо +// public static final short USER_PROFILE= 4; // профиль пользователя да надо //} \ No newline at end of file diff --git a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/MsgSubType.java b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/MsgSubType.java index b04a25b3..26c5869e 100644 --- a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/MsgSubType.java +++ b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/MsgSubType.java @@ -35,6 +35,8 @@ 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) ===================== */ @@ -53,7 +55,7 @@ public final class MsgSubType { /** * REPLY — ответ на сообщение. - * НЕ в линии. Имеет target (toBlockchainName + blockNumber + hash32). + * НЕ в линии. Имеет target (toLogin + blockNumber + hash32). * Может указывать на чужой блокчейн/чужую линию/чужой канал. */ public static final short TEXT_REPLY = 20; @@ -69,7 +71,7 @@ public final class MsgSubType { /** * REPOST — отложенная будущая заготовка репоста сообщения в линии канала. - * Имеет hasLine + target (toBlockchainName + toBlockGlobalNumber + toBlockHash32) + текст комментария. + * Имеет hasLine + target (toLogin + toBlockGlobalNumber + toBlockHash32) + текст комментария. */ public static final short TEXT_REPOST = 50; @@ -79,6 +81,9 @@ 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). */ diff --git a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/ShineProtocolTags.java b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/ShineProtocolTags.java new file mode 100644 index 00000000..1cf59970 --- /dev/null +++ b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/ShineProtocolTags.java @@ -0,0 +1,17 @@ +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 = "test5591"; + 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"; +} diff --git a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/BodyHasLine.java b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/BodyHasLine.java index 35bac544..521fcdfe 100644 --- a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/BodyHasLine.java +++ b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/BodyHasLine.java @@ -1,21 +1,23 @@ package blockchain.body; /** - * BodyHasLine — для типов, которые имеют линейные поля в body. + * BodyHasLine — типы блоков, которые входят в проверяемую логическую линию. * - * Line-prefix (BigEndian) в НАЧАЛЕ bodyBytes: - * [4] lineCode код линии (root-идентификатор): - * - 0 для дефолтной линии/канала "0" (root = HEADER, blockNumber=0) - * - для канала "X": blockNumber root-блока канала (CREATE_CHANNEL) + * Общая семантика: + * prevLineBlockGlobalNumber — GLOBAL blockNumber предыдущего блока этой линии; + * prevLineBlockHash32 — hash32 предыдущего блока этой линии; + * lineSeq — порядковый номер шага линии. * - * [4] prevLineBlockGlobalNumber глобальный номер предыдущего блока в этой линии - * [32] prevLineBlockHash32 hash32 предыдущего блока в этой линии + * lineCode — логический идентификатор линии: + * - 0 для фиксированных системных линий (TECH, CONNECTION, USER_PROFILE) + * и для дефолтного канала, корнем которого является HEADER #0; + * - для пользовательского канала: GLOBAL blockNumber его CREATE_CHANNEL root. * - * [4] lineSeq порядковый номер сообщения внутри линии (1..N) + * Важно: lineCode не обязан физически присутствовать в body. Для фиксированных + * USER_PROFILE и CONNECTION он выводится из msg_type и метод lineCode() возвращает 0. + * Для TEXT-каналов и TECH-блоков lineCode хранится в body явно. * - * Важно: - * - Проверка связности линии (prevLineBlockGlobalNumber ↔ prevLineBlockHash32) и корректности lineSeq - * выполняется на сервере/в БД при вставке (а не в body.check()). + * Полная проверка хвоста линии, prev hash и lineSeq выполняется сервером при AddBlock. */ public interface BodyHasLine { @@ -26,4 +28,4 @@ public interface BodyHasLine { byte[] prevLineBlockHash32(); int lineSeq(); -} \ No newline at end of file +} diff --git a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/BodyHasTarget.java b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/BodyHasTarget.java index bd8e1780..d22c5122 100644 --- a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/BodyHasTarget.java +++ b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/BodyHasTarget.java @@ -1,31 +1,25 @@ package blockchain.body; -import utils.blockchain.BlockchainNameUtil; - /** - * BodyHasTarget — дополнительный интерфейс для body, которые "ссылаются" на цель (to-поля). + * Body that refers to a logical block target. * - * Новое правило: - * - toLogin НЕ храним в байтах блока. - * - toLogin всегда вычисляется из toBchName по стандарту login+"-NNN". - * - * Все методы могут возвращать null. + * 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. */ public interface BodyHasTarget { + /** Target login; null for own-chain compact EDIT targets. */ + default String toLogin() { return null; } - /** login цели (nullable). Вычисляется из toBchName(). */ - default String toLogin() { - String bch = toBchName(); - if (bch == null) return null; - return BlockchainNameUtil.loginFromBlockchainName(bch); - } + /** Historical fork number recorded by the author; null for compact EDIT targets. */ + default Integer toForkNumber() { return null; } - /** blockchainName цели (nullable). */ - String toBchName(); + /** Runtime-only physical blockchain cache; never serialized in canonical targets. */ + @Deprecated + default String toBchName() { return null; } - /** globalNumber цели (nullable). */ Integer toBlockGlobalNumber(); - - /** hash целевого блока (обычно 32 байта). Может быть null, если ссылки нет. */ byte[] toBlockHashBytes(); -} \ No newline at end of file +} diff --git a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/BodyTargetSupport.java b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/BodyTargetSupport.java new file mode 100644 index 00000000..c2755af7 --- /dev/null +++ b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/BodyTargetSupport.java @@ -0,0 +1,115 @@ +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() + ")"); + } +} diff --git a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/ConnectionBody.java b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/ConnectionBody.java index 1d8da91a..b76d6813 100644 --- a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/ConnectionBody.java +++ b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/ConnectionBody.java @@ -1,286 +1,104 @@ 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; /** - * 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 - * FRIEND=14, UNFRIEND=15 - * KNOWN_PERSON=60, UNKNOWN_PERSON=61 (legacy; accepted but not used by current UI) - * SHINE_CONFIRMED=70, SHINE_UNCONFIRMED=71 - * SHINE_SEEN=74, SHINE_UNSEEN=75 (currently not used by UI) - * OFFICIAL_ACCOUNT_CONFIRMED=80, OFFICIAL_ACCOUNT_UNCONFIRMED=81 - * - * 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) + * 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. */ - -/** - * ========================================================================= - * ПРАВИЛО 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; // из 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 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 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 ((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"); - } - + if ((version & 0xFFFF) != 1 || !isValidSubType(subType)) throw new IllegalArgumentException("Bad Connection header"); 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(); - - 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()); + 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"); } - 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; - + 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; this.subType = subType; this.version = VER; - - this.toBlockchainName = toBlockchainName; + this.toLogin = toLogin; + this.toForkNumber = toForkNumber; this.toBlockGlobalNumber = toBlockGlobalNumber; this.toBlockHash32 = 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); - } - - @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"); - + @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"); return this; } - @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); - + @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"); return bb.array(); } - 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 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 toBlockHash32; } + @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); + } } diff --git a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/ForkBody.java b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/ForkBody.java new file mode 100644 index 00000000..64ededa2 --- /dev/null +++ b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/ForkBody.java @@ -0,0 +1,235 @@ +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'); + } +} diff --git a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/HeaderBody.java b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/HeaderBody.java index 4f70b1f4..bc0089ed 100644 --- a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/HeaderBody.java +++ b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/HeaderBody.java @@ -5,123 +5,107 @@ 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, version=1. - * - * В новом формате type/subType/version живут в HEADER блока, - * поэтому bodyBytes для HeaderBody содержат только payload: + * HeaderBody — type=0, subType=0, version=1. * * bodyBytes (BigEndian): - * [TAG_LEN] tag ASCII "SHiNE" - * [1] loginLength=N (uint8) - * [N] login UTF-8 + * [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. */ 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; // всегда 0 (из заголовка блока) - public final short version; // из заголовка блока - public final String tag; // "SHiNE" + public final short subType; + public final short version; + public final String tag; 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 ((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"); + 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"); ByteBuffer bb = ByteBuffer.wrap(bodyBytes).order(ByteOrder.BIG_ENDIAN); - byte[] tagBytes = new byte[TAG_LEN]; bb.get(tagBytes); - String t = new String(tagBytes, StandardCharsets.US_ASCII); - if (!TAG.equals(t)) throw new IllegalArgumentException("Bad tag: " + t); - this.tag = t; + String parsedTag = new String(tagBytes, StandardCharsets.US_ASCII); + if (!TAG.equals(parsedTag)) throw new IllegalArgumentException("Bad tag: " + parsedTag); + this.tag = parsedTag; int loginLen = Byte.toUnsignedInt(bb.get()); - if (loginLen <= 0 || bb.remaining() < loginLen) - throw new IllegalArgumentException("Bad login length"); - + if (loginLen <= 0 || bb.remaining() != loginLen + 32) throw new IllegalArgumentException("Bad HeaderBody login/key length"); byte[] loginBytes = new byte[loginLen]; bb.get(loginBytes); - this.login = new String(loginBytes, StandardCharsets.UTF_8); - - if (bb.remaining() != 0) throw new IllegalArgumentException("Unexpected tail bytes, remaining=" + bb.remaining()); + 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"); } - /** Создание “вручную”. */ - public HeaderBody(String login) { + public HeaderBody(String login, byte[] initialBlockchainKey32) { 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) != (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_]+$"); - + if ((subType & 0xFFFF) != 0) 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_]+$"); + byte[] loginUtf8 = login.getBytes(StandardCharsets.UTF_8); + if (loginUtf8.length == 0 || loginUtf8.length > 255) throw new IllegalArgumentException("Login utf8 len must be 1..255"); + requireNonZeroKey(initialBlockchainKey32); return this; } @Override public byte[] toBytes() { + check(); byte[] loginUtf8 = login.getBytes(StandardCharsets.UTF_8); - 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); + ByteBuffer bb = ByteBuffer.allocate(TAG_LEN + 1 + loginUtf8.length + 32).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"); + } + @Override public String toString() { - return """ - HeaderBody { - тип записи : HEADER (type=0, ver=1) [в заголовке блока] - subType : 0 (compat) - тег формата : "%s" - login владельца : "%s" - } - """.formatted(tag, login); + return "HeaderBody{login='" + login + "', initialBlockchainKey32=<32 bytes>}"; } -} \ No newline at end of file +} diff --git a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/ReactionBody.java b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/ReactionBody.java index 432c3ab4..e1bf37cb 100644 --- a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/ReactionBody.java +++ b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/ReactionBody.java @@ -4,130 +4,68 @@ import blockchain.MsgSubType; import java.nio.ByteBuffer; import java.nio.ByteOrder; -import java.nio.charset.StandardCharsets; import java.util.Arrays; import java.util.Objects; -/** - * 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) - * - * ЛИНИИ НЕТ. - */ +/** REACTION LIKE/UNLIKE. External target = login + forkNumber + blockNumber + hash32. */ 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; // из header - public final short version; // из header - - public final String toBlockchainName; + public final short subType; + public final short version; + public final String toLogin; + public final int toForkNumber; 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 ((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"); - + if ((version & 0xFFFF) != (VER & 0xFFFF)) throw new IllegalArgumentException("ReactionBody version must be 1"); + if (!isSupportedSubType(subType)) throw new IllegalArgumentException("Bad reaction subType: " + (subType & 0xFFFF)); ByteBuffer bb = ByteBuffer.wrap(bodyBytes).order(ByteOrder.BIG_ENDIAN); - - 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()); + 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"); } - public ReactionBody(String toBlockchainName, int toBlockGlobalNumber, byte[] toBlockHash32) { - Objects.requireNonNull(toBlockchainName, "toBlockchainName == null"); - Objects.requireNonNull(toBlockHash32, "toBlockHash32 == null"); - - this.subType = MsgSubType.REACTION_LIKE; + 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; this.version = VER; - - 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.toLogin = toLogin; + this.toForkNumber = toForkNumber; this.toBlockGlobalNumber = toBlockGlobalNumber; this.toBlockHash32 = Arrays.copyOf(toBlockHash32, 32); } - @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"); - + @Override public ReactionBody check() { + if (!isSupportedSubType(subType)) throw new IllegalArgumentException("Bad reaction subType"); + BodyTargetSupport.validateExternal(toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "REACTION"); return this; } - @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); - + @Override public byte[] toBytes() { + check(); + ByteBuffer bb = ByteBuffer.allocate(BodyTargetSupport.externalSize(toLogin)).order(ByteOrder.BIG_ENDIAN); + BodyTargetSupport.writeExternal(bb, toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "REACTION"); return bb.array(); } - /* ====================== BodyHasTarget ====================== */ - - @Override public String toBchName() { return toBlockchainName; } + @Override public String toLogin() { return toLogin; } + @Override public Integer toForkNumber() { return toForkNumber; } @Override public Integer toBlockGlobalNumber() { return toBlockGlobalNumber; } - @Override public byte[] toBlockHashBytes() { return toBlockHash32; } + @Override public byte[] toBlockHashBytes() { return Arrays.copyOf(toBlockHash32, 32); } 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); } } diff --git a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/StatusActionBody.java b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/StatusActionBody.java index 3a3bd0b9..e811fc17 100644 --- a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/StatusActionBody.java +++ b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/StatusActionBody.java @@ -10,157 +10,78 @@ import java.nio.charset.StandardCharsets; import java.util.Arrays; import java.util.Objects; -/** - * 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 - */ +/** STATUS_ACTION. External target = login + forkNumber + blockNumber + hash32. */ 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 toBlockchainName; + public final String toLogin; + public final int toForkNumber; 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) != (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)); - } - + this.subType = subType; this.version = version; + if ((version & 0xFFFF) != 1 || !isSupportedSubType(subType)) throw new IllegalArgumentException("Bad STATUS_ACTION header"); ByteBuffer bb = ByteBuffer.wrap(bodyBytes).order(ByteOrder.BIG_ENDIAN); - 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"); + 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"); } - public StatusActionBody(short subType, String toBlockchainName, int toBlockGlobalNumber, byte[] toBlockHash32, String message) { - Objects.requireNonNull(toBlockchainName, "toBlockchainName == null"); - Objects.requireNonNull(toBlockHash32, "toBlockHash32 == null"); + public StatusActionBody(short subType, String toLogin, int toForkNumber, int toBlockGlobalNumber, byte[] toBlockHash32, String message) { Objects.requireNonNull(message, "message == null"); if (!isSupportedSubType(subType)) throw new IllegalArgumentException("Unsupported STATUS_ACTION subType"); - 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; + 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; } - @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"); - } + @Override public StatusActionBody check() { + if (!isSupportedSubType(subType)) throw new IllegalArgumentException("Bad STATUS_ACTION subType"); + BodyTargetSupport.validateExternal(toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "STATUS_ACTION"); 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() { - 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); + @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); return bb.array(); } - @Override public String toBchName() { return toBlockchainName; } + @Override public String toLogin() { return toLogin; } + @Override public Integer toForkNumber() { return toForkNumber; } @Override public Integer toBlockGlobalNumber() { return toBlockGlobalNumber; } - @Override public byte[] toBlockHashBytes() { return toBlockHash32; } + @Override public byte[] toBlockHashBytes() { return Arrays.copyOf(toBlockHash32, 32); } 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 readStrictUtf8Len16AllowEmpty(ByteBuffer bb, String fieldName) { + private static String readText(ByteBuffer bb) { + if (bb.remaining() < 2) throw new IllegalArgumentException("STATUS_ACTION text length missing"); int len = Short.toUnsignedInt(bb.getShort()); + if (bb.remaining() < len) throw new IllegalArgumentException("STATUS_ACTION text payload too short"); if (len == 0) return ""; - 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()); + 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); } } } diff --git a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/TextBody.java b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/TextBody.java deleted file mode 100644 index 138102e5..00000000 --- a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/TextBody.java +++ /dev/null @@ -1,544 +0,0 @@ -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); - } -} \ No newline at end of file diff --git a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/TextLineBody.java b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/TextLineBody.java index 8f3b4917..9533b5be 100644 --- a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/TextLineBody.java +++ b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/TextLineBody.java @@ -11,374 +11,177 @@ import java.util.Arrays; import java.util.Objects; /** - * 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): + * Line-based TEXT body. * * POST / CHANNEL_META / ENTRYPOINT / EXERCISE / SERVICE / COURSE: - * [4] lineCode - * [4] prevLineNumber - * [32] prevLineHash32 - * [4] thisLineNumber - * [2] textLenBytes (uint16) - * [N] text UTF-8 + * line fields + text * - * EDIT_POST: - * [4] lineCode - * [4] prevLineNumber - * [32] prevLineHash32 - * [4] thisLineNumber - * [4] toBlockGlobalNumber (int32) - * [32] toBlockHash32 - * [2] textLenBytes (uint16) - * [N] text UTF-8 + * EDIT_POST (own-chain compact target): + * line fields + [4] targetBlockNumber + [32] targetHash + 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 + * REPOST (external target): + * line fields + [1]loginLen + login + [2]forkNumber + [4]blockNumber + [32]hash + text */ 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; // из header - public final short version; // из header (=1) - - // line + public final short subType; + public final short version; public final int lineCode; public final int prevLineNumber; - public final byte[] prevLineHash32; // 32 (может быть нули) + public final byte[] prevLineHash32; public final int thisLineNumber; - - // 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 toLogin; + public final Integer toForkNumber; + public final Integer toBlockGlobalNumber; + public final byte[] toBlockHash32; 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 ((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); - } + if ((version & 0xFFFF) != 1 || !isSupportedSubType(subType)) throw new IllegalArgumentException("Bad TextLineBody header"); ByteBuffer bb = ByteBuffer.wrap(bodyBytes).order(ByteOrder.BIG_ENDIAN); - - // минимум line + textLen(2) - ensureMin(bb, (4 + 4 + 32 + 4) + 2, "TextLineBody too short"); - + BodyTargetSupport.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)) { - // нужен 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)) { - 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); + 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); + this.toBlockHash32 = new byte[32]; bb.get(this.toBlockHash32); + BodyTargetSupport.validateCompact(this.toBlockGlobalNumber, this.toBlockHash32, "EDIT_POST"); + } 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(); } else { - this.toBlockchainName = null; + this.toLogin = null; + this.toForkNumber = null; this.toBlockGlobalNumber = null; this.toBlockHash32 = null; } - this.message = readStrictUtf8Len16(bb, "TextLineBody text", - st == (MsgSubType.TEXT_EDIT_POST & 0xFFFF) || st == (MsgSubType.TEXT_CHANNEL_META & 0xFFFF)); - - ensureNoTail(bb, "TextLineBody"); + 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"); } - /* ====================== 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"); - - 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 (!isSupportedSubType(subType)) throw new IllegalArgumentException("Bad TextLineBody subtype"); 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; - - 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_REPOST & 0xFFFF)) { - 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 { - this.toBlockchainName = null; - this.toBlockGlobalNumber = null; - this.toBlockHash32 = null; - } - + 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() { - 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); - + @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"); + 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"); - 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"); + BodyTargetSupport.validateExternal(toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "REPOST"); + if (message == null || message.isBlank()) throw new IllegalArgumentException("REPOST message is blank"); } else { + if (toLogin != null || toForkNumber != null || toBlockGlobalNumber != null || toBlockHash32 != null) { + throw new IllegalArgumentException("Non-target text body must not contain target fields"); + } if (st == (MsgSubType.TEXT_CHANNEL_META & 0xFFFF)) { if (message == null) throw new IllegalArgumentException("CHANNEL_META message is null"); - } else if (requiresNonBlankMessage(st) && (message == null || message.isBlank())) { + } 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()) { 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() { - byte[] msgUtf8 = message.getBytes(StandardCharsets.UTF_8); - if (msgUtf8.length > 65535) throw new IllegalArgumentException("Text too long (>65535 bytes)"); - + @Override public byte[] toBytes() { + check(); + byte[] text = message.getBytes(StandardCharsets.UTF_8); int st = subType & 0xFFFF; - if (requiresNonBlankMessage(st) && msgUtf8.length == 0) { - throw new IllegalArgumentException("Text payload is empty"); - } - - 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); + int targetSize = 0; + if (st == (MsgSubType.TEXT_EDIT_POST & 0xFFFF)) targetSize = 4 + 32; + else if (st == (MsgSubType.TEXT_REPOST & 0xFFFF)) targetSize = BodyTargetSupport.externalSize(toLogin); + 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); - bb.put(toBlockHash32); + bb.putInt(toBlockGlobalNumber).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); + BodyTargetSupport.writeExternal(bb, toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "REPOST"); } - - bb.putShort((short) msgUtf8.length); - bb.put(msgUtf8); - + bb.putShort((short) text.length).put(text); 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; } - - /* ====================== BodyHasTarget ===================== */ - @Override public String toBchName() { return toBlockchainName; } + @Override public String toLogin() { return toLogin; } + @Override public Integer toForkNumber() { return toForkNumber; } @Override public Integer toBlockGlobalNumber() { return toBlockGlobalNumber; } - @Override public byte[] toBlockHashBytes() { return toBlockHash32; } + @Override public byte[] toBlockHashBytes() { return toBlockHash32 == null ? null : Arrays.copyOf(toBlockHash32, 32); } + public boolean isEditPost() { return (subType & 0xFFFF) == (MsgSubType.TEXT_EDIT_POST & 0xFFFF); } - /* ====================== helpers ====================== */ - - 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); } - 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) { + private static String readText(ByteBuffer bb, boolean allowEmpty) { + if (bb.remaining() < 2) throw new IllegalArgumentException("Text length missing"); int len = Short.toUnsignedInt(bb.getShort()); - 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()); + 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); } } } diff --git a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/TextRatingBody.java b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/TextRatingBody.java index 270a3904..13bee94a 100644 --- a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/TextRatingBody.java +++ b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/TextRatingBody.java @@ -10,29 +10,16 @@ import java.nio.charset.StandardCharsets; import java.util.Arrays; import java.util.Objects; -/** - * 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 - */ +/** TEXT_RATING. External target = login + forkNumber + blockNumber + hash32. */ 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 toBlockchainName; + public final String toLogin; + public final int toForkNumber; public final int toBlockGlobalNumber; public final byte[] toBlockHash32; public final String message; @@ -41,117 +28,60 @@ 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, got=" + (version & 0xFFFF)); - } - 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"); + if ((subType & 0xFFFF) != (MsgSubType.TEXT_RATING & 0xFFFF)) throw new IllegalArgumentException("TextRatingBody supports only TEXT_RATING"); ByteBuffer bb = ByteBuffer.wrap(bodyBytes).order(ByteOrder.BIG_ENDIAN); - 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"); + 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"); } - public TextRatingBody(String toBlockchainName, int toBlockGlobalNumber, byte[] toBlockHash32, String message) { - Objects.requireNonNull(toBlockchainName, "toBlockchainName == null"); - Objects.requireNonNull(toBlockHash32, "toBlockHash32 == null"); + public TextRatingBody(String toLogin, int toForkNumber, int toBlockGlobalNumber, byte[] toBlockHash32, String message) { 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.toBlockchainName = toBlockchainName; + this.toLogin = toLogin; + this.toForkNumber = toForkNumber; 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 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"); - } + @Override public TextRatingBody check() { + if ((subType & 0xFFFF) != (MsgSubType.TEXT_RATING & 0xFFFF)) throw new IllegalArgumentException("Bad RATING subType"); + BodyTargetSupport.validateExternal(toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "RATING"); 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() { - 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); + @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); return bb.array(); } - @Override public String toBchName() { return toBlockchainName; } + @Override public String toLogin() { return toLogin; } + @Override public Integer toForkNumber() { return toForkNumber; } @Override public Integer toBlockGlobalNumber() { return toBlockGlobalNumber; } - @Override public byte[] toBlockHashBytes() { return toBlockHash32; } + @Override public byte[] toBlockHashBytes() { return Arrays.copyOf(toBlockHash32, 32); } - private static String readStrictUtf8Len16(ByteBuffer bb, String fieldName) { + private static String readText(ByteBuffer bb) { + if (bb.remaining() < 2) throw new IllegalArgumentException("RATING text length missing"); 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()); + 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); } } } diff --git a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/TextReplyBody.java b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/TextReplyBody.java index ceeae92a..b57cdb12 100644 --- a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/TextReplyBody.java +++ b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/TextReplyBody.java @@ -11,241 +11,111 @@ import java.util.Arrays; import java.util.Objects; /** - * 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 + * TEXT_REPLY / TEXT_EDIT_REPLY. + * REPLY external target: login + forkNumber + blockNumber + hash32. + * EDIT_REPLY compact own-chain target: blockNumber + hash32. */ 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; // из header - public final short version; // (=1) - - // target - public final String toBlockchainName; // nullable для EDIT_REPLY + public final short subType; + public final short version; + public final String toLogin; + public final Integer toForkNumber; public final int toBlockGlobalNumber; - public final byte[] toBlockHash32; // 32 - - // text + public final byte[] toBlockHash32; public final String message; public TextReplyBody(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("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); - } + 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"); ByteBuffer bb = ByteBuffer.wrap(bodyBytes).order(ByteOrder.BIG_ENDIAN); - if (st == (MsgSubType.TEXT_REPLY & 0xFFFF)) { - // минимум: 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); - + 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 { - // EDIT_REPLY: target без имени - ensureMin(bb, (4 + 32) + 2, "EDIT_REPLY too short"); - - this.toBlockchainName = null; + BodyTargetSupport.ensureMin(bb, 4 + 32 + 2, "EDIT_REPLY too short"); + 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_REPLY"); } - - this.message = readStrictUtf8Len16(bb, "TextReplyBody text", st == (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF)); - ensureNoTail(bb, "TextReplyBody"); + this.message = readText(bb, st == (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF)); + if (bb.hasRemaining()) throw new IllegalArgumentException("Unexpected TextReplyBody tail"); } - public TextReplyBody(short subType, - int toBlockGlobalNumber, - byte[] toBlockHash32, - String toBlockchainName, - String message) { - + public TextReplyBody(short subType, String toLogin, Integer toForkNumber, int toBlockGlobalNumber, byte[] toBlockHash32, 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("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) && st != (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF)) throw new IllegalArgumentException("Bad reply subtype"); if (st == (MsgSubType.TEXT_REPLY & 0xFFFF)) { - Objects.requireNonNull(toBlockchainName, "toBlockchainName == null"); - if (toBlockchainName.isBlank()) throw new IllegalArgumentException("toBlockchainName is blank"); - this.toBlockchainName = toBlockchainName; + if (message.isBlank()) throw new IllegalArgumentException("REPLY message is blank"); + BodyTargetSupport.validateExternal(toLogin, toForkNumber, toBlockGlobalNumber, toBlockHash32, "REPLY"); } else { - // EDIT_REPLY: имя не хранить - this.toBlockchainName = null; + if (toLogin != null || toForkNumber != null) throw new IllegalArgumentException("EDIT_REPLY must not contain login/fork target"); + BodyTargetSupport.validateCompact(toBlockGlobalNumber, toBlockHash32, "EDIT_REPLY"); } - 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)) { - 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 { + 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) throw new IllegalArgumentException("EDIT_REPLY message is null"); - if (toBlockchainName != null) - throw new IllegalArgumentException("EDIT_REPLY must not contain toBlockchainName"); - } - + } else throw new IllegalArgumentException("Bad reply subtype"); + if (message.getBytes(StandardCharsets.UTF_8).length > 65535) throw new IllegalArgumentException("Text too long"); return this; } - @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); - + @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); return bb.array(); } - /* ====================== BodyHasTarget ====================== */ - - @Override public String toBchName() { return toBlockchainName; } + @Override public String toLogin() { return toLogin; } + @Override public Integer toForkNumber() { return toForkNumber; } @Override public Integer toBlockGlobalNumber() { return toBlockGlobalNumber; } - @Override public byte[] toBlockHashBytes() { return toBlockHash32; } + @Override public byte[] toBlockHashBytes() { return Arrays.copyOf(toBlockHash32, 32); } + public boolean isEditReply() { return (subType & 0xFFFF) == (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF); } - public boolean isEditReply() { - return (subType & 0xFFFF) == (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF); - } - - /* ====================== helpers ====================== */ - - private static String readStrictUtf8Len16(ByteBuffer bb, String fieldName, boolean allowEmpty) { + private static String readText(ByteBuffer bb, boolean allowEmpty) { + if (bb.remaining() < 2) throw new IllegalArgumentException("Text length missing"); int len = Short.toUnsignedInt(bb.getShort()); - 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()); + 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); } } } diff --git a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/UserParamBody.java b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/UserParamBody.java index 0ff58aab..519355cc 100644 --- a/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/UserParamBody.java +++ b/SHiNE-server/shine-server-blockchain/src/main/java/blockchain/body/UserParamBody.java @@ -11,16 +11,16 @@ import java.util.Arrays; import java.util.Objects; /** - * UserParamBody — type=4, ver=1 (в заголовке блока). + * UserParamBody — type=4, ver=1 (в документации: USER_PROFILE). * * subType (в заголовке блока): * 1 = TEXT_TEXT * - * bodyBytes (BigEndian), новый формат: - * [4] lineCode - * [4] prevLineNumber - * [32] prevLineHash32 - * [4] thisLineNumber + * USER_PROFILE имеет единственную фиксированную линию, поэтому lineCode в body не хранится. + * bodyBytes (BigEndian): + * [4] prevProfileBlockNumber — GLOBAL blockNumber предыдущего USER_PROFILE-блока + * [32] prevProfileBlockHash32 — hash32 предыдущего USER_PROFILE-блока + * [4] profileSequence — порядковый номер изменения профиля (1..N) * * [2] keyLenBytes (uint16) * [N] keyUtf8 @@ -35,14 +35,12 @@ public final class UserParamBody implements BodyRecord, BodyHasLine { public static final int KEY = ((TYPE & 0xFFFF) << 16) | (VER & 0xFFFF); - public final short subType; // из header - public final short version; // из header + public final short subType; + public final short version; - // line - public final int lineCode; - public final int prevLineNumber; - public final byte[] prevLineHash32; - public final int thisLineNumber; + public final int prevProfileBlockNumber; + public final byte[] prevProfileBlockHash32; + public final int profileSequence; public final String paramKey; public final String paramValue; @@ -60,21 +58,17 @@ public final class UserParamBody implements BodyRecord, BodyHasLine { throw new IllegalArgumentException("Bad UserParam subType: " + (this.subType & 0xFFFF)); } - // минимум: 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) { + // prevGlobal(4)+prevHash(32)+seq(4) + keyLen(2)+key(1) + valLen(2)+val(1) + if (bodyBytes.length < 4 + 32 + 4 + 2 + 1 + 2 + 1) { throw new IllegalArgumentException("UserParamBody 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.prevProfileBlockNumber = bb.getInt(); + this.prevProfileBlockHash32 = new byte[32]; + bb.get(this.prevProfileBlockHash32); + this.profileSequence = bb.getInt(); int keyLen = Short.toUnsignedInt(bb.getShort()); if (keyLen <= 0) throw new IllegalArgumentException("paramKeyLen is 0"); @@ -99,25 +93,21 @@ public final class UserParamBody implements BodyRecord, BodyHasLine { if (this.paramValue.isBlank()) throw new IllegalArgumentException("paramValue is blank"); } - public UserParamBody(int lineCode, - int prevLineNumber, - byte[] prevLineHash32, - int thisLineNumber, + public UserParamBody(int prevProfileBlockNumber, + byte[] prevProfileBlockHash32, + int profileSequence, 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.lineCode = lineCode; - this.prevLineNumber = prevLineNumber; - this.prevLineHash32 = (prevLineHash32 == null ? new byte[32] : Arrays.copyOf(prevLineHash32, 32)); - this.thisLineNumber = thisLineNumber; + this.prevProfileBlockNumber = prevProfileBlockNumber; + this.prevProfileBlockHash32 = (prevProfileBlockHash32 == null ? new byte[32] : Arrays.copyOf(prevProfileBlockHash32, 32)); + this.profileSequence = profileSequence; if (paramKey.isBlank()) throw new IllegalArgumentException("paramKey is blank"); if (paramValue.isBlank()) throw new IllegalArgumentException("paramValue is blank"); @@ -128,17 +118,12 @@ public final class UserParamBody implements BodyRecord, BodyHasLine { @Override public UserParamBody check() { - if (lineCode < 0) throw new IllegalArgumentException("lineCode < 0"); - - if ((subType & 0xFFFF) != (MsgSubType.USER_PARAM_TEXT_TEXT & 0xFFFF)) + 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"); @@ -148,30 +133,25 @@ 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 + (4 + 32 + 4) + int cap = 4 + 32 + 4 + 2 + keyUtf8.length + 2 + valUtf8.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(prevProfileBlockNumber); + bb.put(prevProfileBlockHash32); + bb.putInt(profileSequence); bb.putShort((short) keyUtf8.length); bb.put(keyUtf8); - bb.putShort((short) valUtf8.length); bb.put(valUtf8); - return bb.array(); } @@ -187,15 +167,9 @@ public final class UserParamBody implements BodyRecord, BodyHasLine { } } - 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; } -} \ No newline at end of file + /* 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; } +} diff --git a/SHiNE-server/shine-server-blockchain/src/main/java/utils/blockchain/BlockchainNameUtil.java b/SHiNE-server/shine-server-blockchain/src/main/java/utils/blockchain/BlockchainNameUtil.java index acc55c64..0f2e3edf 100644 --- a/SHiNE-server/shine-server-blockchain/src/main/java/utils/blockchain/BlockchainNameUtil.java +++ b/SHiNE-server/shine-server-blockchain/src/main/java/utils/blockchain/BlockchainNameUtil.java @@ -1,71 +1,54 @@ 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 { - - /** - * Теперь новое правило: - * blockchainName = login + "-"+ 3 цифры - * Пример: "Dima-001" -> "Dima" - * - * Сколько символов отрезаем с конца blockchainName, чтобы получить login: "-001" = 4 - */ - public static final int BLOCKCHAIN_NAME_LOGIN_SUFFIX_LEN = 4; + 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; private BlockchainNameUtil() {} - /** - * Извлечь login из blockchainName: отрезаем последние 4 символа ("-NNN"). - * Пример: "Dima-001" -> "Dima" - */ public static String loginFromBlockchainName(String blockchainName) { - if (blockchainName == null) return null; + Matcher m = matcher(blockchainName); + return m == null ? null : m.group(1); + } - String s = blockchainName.trim(); - if (!hasDashAnd3DigitsSuffix(s)) return null; - - return s.substring(0, s.length() - BLOCKCHAIN_NAME_LOGIN_SUFFIX_LEN); + 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; } - /** - * Проверка правила: - * - 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); + if (login == null || login.isBlank()) return false; + String extracted = loginFromBlockchainName(blockchainName); + return extracted != null && Objects.equals(extracted, login.trim()); } - 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); + 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 boolean isDigit(char c) { - return c >= '0' && c <= '9'; + 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; + } } -} \ No newline at end of file +} diff --git a/SHiNE-server/shine-server-blockchain/src/test/java/blockchain/Ans104DataItemTest.java b/SHiNE-server/shine-server-blockchain/src/test/java/blockchain/Ans104DataItemTest.java index 2350b93b..d53edea2 100644 --- a/SHiNE-server/shine-server-blockchain/src/test/java/blockchain/Ans104DataItemTest.java +++ b/SHiNE-server/shine-server-blockchain/src/test/java/blockchain/Ans104DataItemTest.java @@ -15,8 +15,8 @@ final class Ans104DataItemTest { byte[] owner = Ed25519Util.derivePublicKey(privateKey); byte[] data = "frame-v1-test".getBytes(StandardCharsets.UTF_8); List tags = List.of( - new Ans104DataItem.Tag("App", "test5590"), - new Ans104DataItem.Tag("c_test5590", "books") + 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); @@ -27,8 +27,8 @@ final class Ans104DataItemTest { assertEquals(2, parsed.signatureType()); assertArrayEquals(owner, parsed.owner32()); assertArrayEquals(data, parsed.data()); - assertTrue(parsed.hasTag("App", "test5590")); - assertEquals("books", parsed.tagValue("c_test5590")); + 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); } @@ -38,7 +38,7 @@ final class Ans104DataItemTest { byte[] privateKey = Ed25519Util.generatePrivateKeyFromString("shine-ans104-mutation-key"); byte[] owner = Ed25519Util.derivePublicKey(privateKey); byte[] data = "original".getBytes(StandardCharsets.UTF_8); - List tags = List.of(new Ans104DataItem.Tag("App", "test5590")); + List 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; @@ -50,8 +50,8 @@ final class Ans104DataItemTest { for (int i = 0; i < owner.length; i++) owner[i] = (byte) i; byte[] data = "frame-v1-test".getBytes(StandardCharsets.UTF_8); List tags = List.of( - new Ans104DataItem.Tag("App", "test5590"), - new Ans104DataItem.Tag("c_test5590", "books") + 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); diff --git a/SHiNE-server/shine-server-blockchain/src/test/java/blockchain/ForkBodyTest.java b/SHiNE-server/shine-server-blockchain/src/test/java/blockchain/ForkBodyTest.java new file mode 100644 index 00000000..eb2a3561 --- /dev/null +++ b/SHiNE-server/shine-server-blockchain/src/test/java/blockchain/ForkBodyTest.java @@ -0,0 +1,100 @@ +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; + } +} diff --git a/SHiNE-server/shine-server-blockchain/src/test/java/blockchain/TargetLoginFormatTest.java b/SHiNE-server/shine-server-blockchain/src/test/java/blockchain/TargetLoginFormatTest.java new file mode 100644 index 00000000..d5f89ff9 --- /dev/null +++ b/SHiNE-server/shine-server-blockchain/src/test/java/blockchain/TargetLoginFormatTest.java @@ -0,0 +1,106 @@ +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); + } + + private static byte[] hash(int seed) { + byte[] out = new byte[32]; + Arrays.fill(out, (byte) seed); + return out; + } +} diff --git a/SHiNE-server/shine-server-config/src/main/java/utils/config/ShineSignatureConstants.java b/SHiNE-server/shine-server-config/src/main/java/utils/config/ShineSignatureConstants.java index fd730bba..eeda4be6 100644 --- a/SHiNE-server/shine-server-config/src/main/java/utils/config/ShineSignatureConstants.java +++ b/SHiNE-server/shine-server-config/src/main/java/utils/config/ShineSignatureConstants.java @@ -20,8 +20,8 @@ public final class ShineSignatureConstants { /** Подписанный 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"; diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java index 9c19edf7..5ac9710d 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java @@ -17,56 +17,13 @@ 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_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 int SCHEMA_VERSION_11 = 11; - public static final int SCHEMA_VERSION_12 = 12; - public static final int SCHEMA_VERSION_13 = 13; - public static final int SCHEMA_VERSION_14 = 14; - public static final int SCHEMA_VERSION_15 = 15; - public static final int SCHEMA_VERSION_16 = 16; - public static final int SCHEMA_VERSION_17 = 17; - public static final int SCHEMA_VERSION_18 = 18; - public static final int SCHEMA_VERSION_19 = 19; - public static final int SCHEMA_VERSION_20 = 20; - public static final int SCHEMA_VERSION_21 = 21; - public static final int SCHEMA_VERSION_22 = 22; - public static final int SCHEMA_VERSION_23 = 23; - public static final int SCHEMA_VERSION_24 = 24; - public static final int SCHEMA_VERSION_25 = 25; + public static final int SCHEMA_VERSION_31 = 31; public static final String POSTGRES_SCHEMA_RESOURCE = "postgres/schema_v1.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"; - public static final String POSTGRES_MIGRATION_V11_RESOURCE = "postgres/migration_v11.sql"; - public static final String POSTGRES_MIGRATION_V12_RESOURCE = "postgres/migration_v12.sql"; - public static final String POSTGRES_MIGRATION_V13_RESOURCE = "postgres/migration_v13.sql"; - public static final String POSTGRES_MIGRATION_V14_RESOURCE = "postgres/migration_v14.sql"; - public static final String POSTGRES_MIGRATION_V15_RESOURCE = "postgres/migration_v15.sql"; - public static final String POSTGRES_MIGRATION_V16_RESOURCE = "postgres/migration_v16.sql"; - public static final String POSTGRES_MIGRATION_V17_RESOURCE = "postgres/migration_v17.sql"; - public static final String POSTGRES_MIGRATION_V18_RESOURCE = "postgres/migration_v18.sql"; - public static final String POSTGRES_MIGRATION_V19_RESOURCE = "postgres/migration_v19.sql"; - public static final String POSTGRES_MIGRATION_V20_RESOURCE = "postgres/migration_v20.sql"; - public static final String POSTGRES_MIGRATION_V21_RESOURCE = "postgres/migration_v21.sql"; - public static final String POSTGRES_MIGRATION_V22_RESOURCE = "postgres/migration_v22.sql"; - public static final String POSTGRES_MIGRATION_V23_RESOURCE = "postgres/migration_v23.sql"; - public static final String POSTGRES_MIGRATION_V24_RESOURCE = "postgres/migration_v24.sql"; - public static final String POSTGRES_MIGRATION_V25_RESOURCE = "postgres/migration_v25.sql"; + public static final String POSTGRES_MIGRATION_V31_RESOURCE = "postgres/migration_v31.sql"; private DatabaseInitializer() {} @@ -77,6 +34,7 @@ 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; @@ -135,106 +93,35 @@ public final class DatabaseInitializer { } try (Connection conn = openConnection(jdbcUrl, user, password)) { - if (!postgresSchemaVersionTableExists(conn)) { + 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."); + } runSqlScript(conn, POSTGRES_SCHEMA_RESOURCE); - return; + markerTableExists = postgresTableExists(conn, DB_FORMAT_MARKER_TABLE); + schemaVersionTableExists = postgresTableExists(conn, DB_SCHEMA_VERSION_TABLE); } + + 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 < SCHEMA_VERSION_2) { - runSqlScript(conn, POSTGRES_MIGRATION_V2_RESOURCE); - currentVersion = SCHEMA_VERSION_2; + if (currentVersion == 30) { + runSqlScript(conn, POSTGRES_MIGRATION_V31_RESOURCE); + currentVersion = readCurrentSchemaVersion(conn); } - if (currentVersion < SCHEMA_VERSION_3) { - runSqlScript(conn, POSTGRES_MIGRATION_V3_RESOURCE); - currentVersion = SCHEMA_VERSION_3; - } - if (currentVersion < SCHEMA_VERSION_4) { - runSqlScript(conn, POSTGRES_MIGRATION_V4_RESOURCE); - currentVersion = SCHEMA_VERSION_4; - } - if (currentVersion < SCHEMA_VERSION_5) { - runSqlScript(conn, POSTGRES_MIGRATION_V5_RESOURCE); - currentVersion = SCHEMA_VERSION_5; - } - if (currentVersion < SCHEMA_VERSION_6) { - runSqlScript(conn, POSTGRES_MIGRATION_V6_RESOURCE); - currentVersion = SCHEMA_VERSION_6; - } - if (currentVersion < SCHEMA_VERSION_7) { - runSqlScript(conn, POSTGRES_MIGRATION_V7_RESOURCE); - currentVersion = SCHEMA_VERSION_7; - } - if (currentVersion < SCHEMA_VERSION_8) { - runSqlScript(conn, POSTGRES_MIGRATION_V8_RESOURCE); - currentVersion = SCHEMA_VERSION_8; - } - if (currentVersion < SCHEMA_VERSION_9) { - runSqlScript(conn, POSTGRES_MIGRATION_V9_RESOURCE); - currentVersion = SCHEMA_VERSION_9; - } - if (currentVersion < SCHEMA_VERSION_10) { - runSqlScript(conn, POSTGRES_MIGRATION_V10_RESOURCE); - currentVersion = SCHEMA_VERSION_10; - } - if (currentVersion < SCHEMA_VERSION_11) { - runSqlScript(conn, POSTGRES_MIGRATION_V11_RESOURCE); - currentVersion = SCHEMA_VERSION_11; - } - if (currentVersion < SCHEMA_VERSION_12) { - runSqlScript(conn, POSTGRES_MIGRATION_V12_RESOURCE); - currentVersion = SCHEMA_VERSION_12; - } - if (currentVersion < SCHEMA_VERSION_13) { - runSqlScript(conn, POSTGRES_MIGRATION_V13_RESOURCE); - currentVersion = SCHEMA_VERSION_13; - } - if (currentVersion < SCHEMA_VERSION_14) { - runSqlScript(conn, POSTGRES_MIGRATION_V14_RESOURCE); - currentVersion = SCHEMA_VERSION_14; - } - if (currentVersion < SCHEMA_VERSION_15) { - runSqlScript(conn, POSTGRES_MIGRATION_V15_RESOURCE); - currentVersion = SCHEMA_VERSION_15; - } - if (currentVersion < SCHEMA_VERSION_16) { - runSqlScript(conn, POSTGRES_MIGRATION_V16_RESOURCE); - currentVersion = SCHEMA_VERSION_16; - } - if (currentVersion < SCHEMA_VERSION_17) { - runSqlScript(conn, POSTGRES_MIGRATION_V17_RESOURCE); - currentVersion = SCHEMA_VERSION_17; - } - if (currentVersion < SCHEMA_VERSION_18) { - runSqlScript(conn, POSTGRES_MIGRATION_V18_RESOURCE); - currentVersion = SCHEMA_VERSION_18; - } - if (currentVersion < SCHEMA_VERSION_19) { - runSqlScript(conn, POSTGRES_MIGRATION_V19_RESOURCE); - currentVersion = SCHEMA_VERSION_19; - } - if (currentVersion < SCHEMA_VERSION_20) { - runSqlScript(conn, POSTGRES_MIGRATION_V20_RESOURCE); - currentVersion = SCHEMA_VERSION_20; - } - if (currentVersion < SCHEMA_VERSION_21) { - runSqlScript(conn, POSTGRES_MIGRATION_V21_RESOURCE); - currentVersion = SCHEMA_VERSION_21; - } - if (currentVersion < SCHEMA_VERSION_22) { - runSqlScript(conn, POSTGRES_MIGRATION_V22_RESOURCE); - currentVersion = SCHEMA_VERSION_22; - } - if (currentVersion < SCHEMA_VERSION_23) { - runSqlScript(conn, POSTGRES_MIGRATION_V23_RESOURCE); - currentVersion = SCHEMA_VERSION_23; - } - if (currentVersion < SCHEMA_VERSION_24) { - runSqlScript(conn, POSTGRES_MIGRATION_V24_RESOURCE); - currentVersion = SCHEMA_VERSION_24; - } - if (currentVersion < SCHEMA_VERSION_25) { - runSqlScript(conn, POSTGRES_MIGRATION_V25_RESOURCE); - currentVersion = SCHEMA_VERSION_25; + if (currentVersion != SCHEMA_VERSION_31) { + throw new SQLException( + "Unsupported SHiNE DB v2 schema version: expected 31, found " + currentVersion); } } } @@ -246,23 +133,60 @@ public final class DatabaseInitializer { return DriverManager.getConnection(jdbcUrl, user, password == null ? "" : password); } - private static boolean postgresSchemaVersionTableExists(Connection conn) throws SQLException { + private static boolean postgresTableExists(Connection conn, String tableName) 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, DB_SCHEMA_VERSION_TABLE); + ps.setString(1, tableName); 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 diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/MsgSubType.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/MsgSubType.java index 850244a6..29deb792 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/MsgSubType.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/MsgSubType.java @@ -4,7 +4,7 @@ package shine.db; * MsgSubType — единое место для ВСЕХ subType сообщений (msg_sub_type). * * ВАЖНО: - * - Значения должны совпадать с body-классами (TextBody/ReactionBody/ConnectionBody/UserParamBody/HeaderBody). + * - Значения должны совпадать с body-классами (TextLineBody/TextReplyBody/TextRatingBody/ReactionBody/ConnectionBody/UserParamBody/HeaderBody). * - После релиза менять числа нельзя (иначе ломается совместимость данных). */ public final class MsgSubType { @@ -38,6 +38,7 @@ 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; diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/PostgresDbController.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/PostgresDbController.java index a3b77fcc..da69c022 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/PostgresDbController.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/PostgresDbController.java @@ -28,7 +28,7 @@ public final class PostgresDbController { try { DatabaseInitializer.ensurePostgresSchemaInitialized(jdbcUrl, dbUser, dbPassword); } catch (SQLException e) { - throw new RuntimeException("PostgreSQL schema auto-init failed", e); + throw new RuntimeException("PostgreSQL database compatibility/init failed: " + e.getMessage(), e); } this.delegate = new DriverManagerDbProvider(jdbcUrl, dbUser, dbPassword, connection -> { diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ActiveSessionsDAO.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ActiveSessionsDAO.java index cb2e0e88..fa99a617 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ActiveSessionsDAO.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ActiveSessionsDAO.java @@ -269,6 +269,57 @@ public final class ActiveSessionsDAO { } } + /** + * Удаляет все сессии пользователя, кроме указанной текущей, и возвращает их sessionId. + * Вариант с Connection используется внутри транзакции запуска key rotation. + */ + public List deleteOtherSessions(Connection c, String login, String keepSessionId) throws SQLException { + List 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 deleteOtherSessions(String login, String keepSessionId) throws SQLException { + try (Connection c = db.getConnection()) { + boolean oldAutoCommit = c.getAutoCommit(); + c.setAutoCommit(false); + try { + List 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 { diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ArweaveBlockImportDAO.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ArweaveBlockImportDAO.java index 74b8174e..102a8a44 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ArweaveBlockImportDAO.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ArweaveBlockImportDAO.java @@ -13,7 +13,9 @@ public final class ArweaveBlockImportDAO { public record QueueItem(byte[] dataItemId, long blockHeight, byte[] rawDataItem, String status, String lastError, - long firstSeenAtMs, long updatedAtMs) {} + 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(); @@ -51,21 +53,22 @@ public final class ArweaveBlockImportDAO { } /** Insert once. Existing IDs (including REJECTED) are deliberately not re-enqueued. */ - public boolean enqueueIfMissing(byte[] dataItemId, long blockHeight, byte[] rawDataItem, long nowMs) + 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,block_height,raw_data_item,status,last_error,first_seen_at_ms,updated_at_ms - ) VALUES(?,?,?,?, '',?,?) + 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.setLong(2, blockHeight); - ps.setBytes(3, rawDataItem); - ps.setString(4, STATUS_PENDING); - ps.setLong(5, nowMs); + 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; } } @@ -81,7 +84,8 @@ public final class ArweaveBlockImportDAO { public List 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 + 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 @@ -96,13 +100,55 @@ public final class ArweaveBlockImportDAO { 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.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 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 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); } diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlockchainForkSegmentsDAO.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlockchainForkSegmentsDAO.java new file mode 100644 index 00000000..afcb2d88 --- /dev/null +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlockchainForkSegmentsDAO.java @@ -0,0 +1,27 @@ +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();} + } +} diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlockchainResyncCleanupDAO.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlockchainResyncCleanupDAO.java index 4f461d3f..9a9ab254 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlockchainResyncCleanupDAO.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlockchainResyncCleanupDAO.java @@ -1,509 +1,298 @@ package shine.db.dao; -import shine.db.DatabaseInitializer; import shine.db.DbController; - -import java.sql.Connection; -import java.sql.PreparedStatement; -import java.sql.ResultSet; -import java.sql.SQLException; +import java.sql.*; /** - * BlockchainResyncCleanupDAO — подготовительный "жёсткий reset" одной blockchain-цепочки - * перед её полной повторной загрузкой от сервера-партнёра. - * - * Что делает этот DAO: - * 1) в ОДНОЙ SQL-транзакции сначала аккуратно уменьшает чужие агрегаты, - * которые были увеличены блоками удаляемой цепочки: - * - likes_count - * - replies_count - * 2) затем удаляет все локальные записи самой цепочки и её производные состояния. - * - * Почему это вынесено в отдельный DAO-метод, а не в триггеры DELETE: - * - нам нужен один понятный "блок операции", который можно вызвать из resync-flow; - * - эта схема проще и прозрачнее, чем много обратных триггеров по разным таблицам; - * - если любой шаг не удался, делаем rollback и БД остаётся в исходном состоянии; - * - пользовательские blockchain-файлы больше не существуют; cleanup полностью DB-only. - * SQL-транзакция и файловая система не коммитятся атомарно вместе; - * поэтому БД-чистка делается здесь, а файловая чистка будет следующим шагом - * отдельным recovery/resync-слоем после успешного commit. - * - * Важный смысл текущей реализации: - * - мы НЕ трогаем current users слой (`solana_user_pda_current`) и НЕ трогаем DM-таблицы; - * - мы очищаем только блокчейн пользователя и derived-state, который строится из неё; - * - висячие cross-chain ссылки в чужих blocks допускаются как нормальное поведение системы. + * Atomic cleanup of one physical fork before deterministic replay. + * Physical fork identity is (login,fork_number). Incoming logical state is never rebound/deleted. */ 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; } - 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; - } - - /** - * Полностью очищает одну 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. - * - * Отдельно важно: - * - filesystem blockchain storage отсутствует; - * - здесь НЕТ повторной загрузки цепочки; - * - это только атомарная SQL-очистка БД, на которую потом будет опираться resync-flow. - */ public CleanupResult cleanupBlockchainForFullResync(String blockchainName) throws SQLException { - if (blockchainName == null || blockchainName.isBlank()) { - throw new IllegalArgumentException("blockchainName is blank"); - } - - try (Connection c = db.getConnection()) { - boolean oldAutoCommit = c.getAutoCommit(); - c.setAutoCommit(false); - try { - String login = resolveLoginForCleanup(c, blockchainName); - - int likesAdjusted = decreaseForeignLikesCount(c, blockchainName); - int repliesAdjusted = decreaseForeignRepliesCount(c, blockchainName); - - 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); - - rebuildStatsState(c); - - 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 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; - } + 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(); } + + 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();} + + 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"); } - } - String loginFromName = loginFromBlockchainName(blockchainName); - if (loginFromName == null || loginFromName.isBlank()) { - throw new IllegalArgumentException("Cannot derive login from blockchainName: " + blockchainName); - } - return loginFromName; - } + // 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();} - /** - * DAO остаётся в модуле БД и не тянет зависимость на blockchain-utils модуль. - * Поэтому здесь локально повторяем минимальное правило имени chain: - * login + "-NNN". - */ - private String loginFromBlockchainName(String blockchainName) { - if (blockchainName == null) return null; + // 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();} - String s = blockchainName.trim(); - if (s.length() <= BLOCKCHAIN_LOGIN_SUFFIX_LEN) return null; + // 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();} - int dashPos = s.length() - BLOCKCHAIN_LOGIN_SUFFIX_LEN; - if (s.charAt(dashPos) != '-') return null; + // 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();} - 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 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(); - } - } - - /** - * Уменьшаем 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(); - } - } - - /** - * Статистика сообщений самой удаляемой цепочки после 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); - } - - /** - * 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 void rebuildStatsState(Connection c) throws SQLException { - try (PreparedStatement truncate = c.prepareStatement(""" - TRUNCATE TABLE user_stats_state, channel_stats_state - """)) { - truncate.executeUpdate(); - } - - try (PreparedStatement ps = c.prepareStatement(""" - INSERT INTO user_stats_state ( - login, - owned_public_channels_count, - following_users_count, - following_channels_count, - close_friends_count, - updated_at_ms - ) - SELECT - u.login, - COALESCE(own.owned_public_channels_count, 0), - COALESCE(fu.following_users_count, 0), - COALESCE(fc.following_channels_count, 0), - COALESCE(cf.close_friends_count, 0), - CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT) - FROM solana_user_pda_current u - LEFT JOIN ( - SELECT owner_login, COUNT(*)::INTEGER AS owned_public_channels_count - FROM channel_names_state - WHERE channel_type_code = 1 - GROUP BY owner_login - ) own ON LOWER(own.owner_login) = LOWER(u.login) - LEFT JOIN ( - SELECT login, COUNT(*)::INTEGER AS following_users_count - FROM connections_state - WHERE rel_type = 30 - AND to_block_number = 0 - GROUP BY login - ) fu ON LOWER(fu.login) = LOWER(u.login) - LEFT JOIN ( - SELECT cs.login, COUNT(*)::INTEGER AS following_channels_count + // 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 cn.owner_bch_name = cs.to_bch_name - AND cn.channel_root_block_number = cs.to_block_number - AND cn.channel_root_block_hash = cs.to_block_hash - WHERE cs.rel_type = 30 - AND cn.channel_type_code = 1 - GROUP BY cs.login - ) fc ON LOWER(fc.login) = LOWER(u.login) - LEFT JOIN ( - SELECT login, COUNT(*)::INTEGER AS close_friends_count - FROM connections_state - WHERE rel_type = 10 - GROUP BY login - ) cf ON LOWER(cf.login) = LOWER(u.login) - """)) { - ps.executeUpdate(); - } + 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); - try (PreparedStatement ps = c.prepareStatement("SELECT shine_refresh_user_profile(login) FROM solana_user_pda_current")) { - ps.execute(); - } - try (PreparedStatement ps = c.prepareStatement("SELECT shine_refresh_user_stats(login) FROM solana_user_pda_current")) { - ps.execute(); - } - try (PreparedStatement ps = c.prepareStatement(""" - UPDATE message_stats ms SET - 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_bch_name=ms.to_bch_name 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_bch_name=ms.to_bch_name 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)) - """)) { - ps.executeUpdate(); - } + // 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); - try (PreparedStatement ps = c.prepareStatement(""" - INSERT INTO channel_stats_state ( - owner_bch_name, - channel_root_block_number, - channel_root_block_hash, - owner_login, - channel_type_code, - subscribers_count, - updated_at_ms - ) - SELECT - cn.owner_bch_name, - cn.channel_root_block_number, - cn.channel_root_block_hash, - cn.owner_login, - cn.channel_type_code, - COUNT(DISTINCT cs.login)::INTEGER AS subscribers_count, - CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT) - FROM channel_names_state cn - LEFT JOIN connections_state cs - ON cs.rel_type = 30 - AND cs.to_bch_name = cn.owner_bch_name - AND cs.to_block_number = cn.channel_root_block_number - AND cs.to_block_hash = cn.channel_root_block_hash - WHERE cn.channel_type_code = 1 - GROUP BY - cn.owner_bch_name, - cn.channel_root_block_number, - cn.channel_root_block_hash, - cn.owner_login, - cn.channel_type_code - """)) { - ps.executeUpdate(); - } - } + // 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+"-%"); - private int executeDelete(Connection c, String sql, String value) throws SQLException { - try (PreparedStatement ps = c.prepareStatement(sql)) { - ps.setString(1, value); - return ps.executeUpdate(); - } + 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);}} } /** - * Технический результат cleanup-операции. - * Нужен для будущего логирования и ручной диагностики resync-flow. + * 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. */ - 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 - ) {} + 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();} + + // 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();} + + // 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();} + + 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);}} + } + + 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 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 + ) + 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();} + } + } + + 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();} + } + } + + 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);} } + + public record CleanupResult(String login,int deletedReactionsStateRows,int deletedConnectionsStateRows,int deletedUsersParamsRows,int deletedChannelNamesRows,int deletedChat200StateRows,int deletedChat200MembersRows,int deletedBlocksRows,int deletedBlockchainStateRows){} } diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlockchainStateDAO.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlockchainStateDAO.java index e2ad176a..7f52aed1 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlockchainStateDAO.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlockchainStateDAO.java @@ -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,11 +43,13 @@ public final class BlockchainStateDAO { last_block_hash, updated_at_ms FROM blockchain_state - WHERE blockchain_name = ? + WHERE login = ? AND fork_number = ? """; try (PreparedStatement ps = c.prepareStatement(sql)) { - ps.setString(1, blockchainName); + ChainRef r=chainRef(blockchainName); + ps.setString(1, r.login()); + ps.setInt(2, r.fork()); try (ResultSet rs = ps.executeQuery()) { if (!rs.next()) return null; return mapRow(rs); @@ -66,8 +68,8 @@ public final class BlockchainStateDAO { public List listAll(Connection c) throws SQLException { String sql = """ SELECT - blockchain_name, login, + fork_number, blockchain_key, size_limit, file_size_bytes, @@ -75,7 +77,7 @@ public final class BlockchainStateDAO { last_block_hash, updated_at_ms FROM blockchain_state - ORDER BY LOWER(blockchain_name) + ORDER BY LOWER(login), fork_number """; List result = new ArrayList<>(); @@ -98,9 +100,9 @@ public final class BlockchainStateDAO { /** UPSERT с внешним соединением. Соединение НЕ закрывает. */ public void upsert(Connection c, BlockchainStateEntry e) throws SQLException { String sql = """ - INSERT INTO blockchain_state ( - blockchain_name, + INSERT INTO blockchain_state_store ( login, + fork_number, blockchain_key, size_limit, file_size_bytes, @@ -108,9 +110,8 @@ public final class BlockchainStateDAO { last_block_hash, updated_at_ms ) VALUES (?, ?, ?, ?, ?, ?, ?, ?) - ON CONFLICT(blockchain_name) + ON CONFLICT(login, fork_number) DO UPDATE SET - login = excluded.login, blockchain_key = excluded.blockchain_key, size_limit = excluded.size_limit, file_size_bytes = excluded.file_size_bytes, @@ -122,8 +123,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()); @@ -148,9 +149,9 @@ public final class BlockchainStateDAO { */ public boolean insertIfMissing(Connection c, BlockchainStateEntry e) throws SQLException { String sql = """ - INSERT INTO blockchain_state ( - blockchain_name, + INSERT INTO blockchain_state_store ( login, + fork_number, blockchain_key, size_limit, file_size_bytes, @@ -158,14 +159,14 @@ public final class BlockchainStateDAO { last_block_hash, updated_at_ms ) VALUES (?, ?, ?, ?, ?, ?, ?, ?) - ON CONFLICT(blockchain_name) DO NOTHING + ON CONFLICT(login, fork_number) 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()); @@ -191,20 +192,22 @@ public final class BlockchainStateDAO { */ public boolean tryIncreaseFileSizeWithinLimit(Connection c, String blockchainName, long deltaBytes, long nowMs) throws SQLException { String sql = """ - UPDATE blockchain_state + UPDATE blockchain_state_store SET file_size_bytes = file_size_bytes + ?, updated_at_ms = ? WHERE - blockchain_name = ? + login = ? AND fork_number = ? AND (file_size_bytes + ?) <= size_limit """; try (PreparedStatement ps = c.prepareStatement(sql)) { ps.setLong(1, deltaBytes); ps.setLong(2, nowMs); - ps.setString(3, blockchainName); - ps.setLong(4, deltaBytes); + ChainRef r=chainRef(blockchainName); + ps.setString(3, r.login()); + ps.setInt(4, r.fork()); + ps.setLong(5, deltaBytes); return ps.executeUpdate() > 0; } } @@ -212,8 +215,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")); @@ -227,6 +230,15 @@ 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); diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlocksDAO.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlocksDAO.java index e7783ba6..9d8aa7ab 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlocksDAO.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlocksDAO.java @@ -23,9 +23,9 @@ public final class BlocksDAO { public void insert(Connection c, BlockEntry e) throws SQLException { String sql = """ - 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, + 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 @@ -34,13 +34,13 @@ public final class BlocksDAO { try (PreparedStatement ps = c.prepareStatement(sql)) { int i = 1; ps.setString(i++, e.getLogin()); - ps.setString(i++, e.getBchName()); + ps.setInt(i++, e.getForkNumber()); 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()); - setNullableString(ps, i++, e.getToBchName()); + setNullableInt(ps, i++, e.getToForkNumber()); setNullableInt(ps, i++, e.getToBlockNumber()); setNullableBytes(ps, i++, e.getToBlockHash()); ps.setBytes(i++, e.getBlockHash()); @@ -68,16 +68,26 @@ public final class BlocksDAO { } } + /** Возвращает ещё не опубликованный пользовательский 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 listPendingArweave(int limit) throws SQLException { int safeLimit = Math.max(1, Math.min(limit, 100_000)); 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,data_item_id, + 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 bch_name ASC, block_number ASC + ORDER BY login ASC, fork_number ASC, block_number ASC LIMIT ? """; List out = new ArrayList<>(); @@ -91,7 +101,7 @@ public final class BlocksDAO { public void markArweavePublished(List dataItemIds, long publishedAtMs) throws SQLException { if (dataItemIds == null || dataItemIds.isEmpty()) return; String sql = """ - UPDATE blocks + UPDATE blocks_store SET arweave_publish_pending=FALSE, arweave_published_at_ms=? WHERE data_item_id=? """; @@ -108,30 +118,45 @@ public final class BlocksDAO { } public byte[] getHashByNumber(Connection c, String bchName, int blockNumber) throws SQLException { - try (PreparedStatement ps = c.prepareStatement("SELECT block_hash FROM blocks WHERE bch_name=? AND block_number=? LIMIT 1")) { - ps.setString(1,bchName); ps.setInt(2,blockNumber); + 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; } } } public byte[] getHashByNumber(String bchName, int blockNumber) throws SQLException { try(Connection c=db.getConnection()){return getHashByNumber(c,bchName,blockNumber);} } public BlockEntry getByNumber(Connection c, String bchName, int blockNumber) throws SQLException { - String sql = baseSelect()+" 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()){return rs.next()?mapRow(rs):null;} } + 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);} } + /** Последний принятый блок конкретной логической линии в текущем 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; } + } + } + public BlockEntry getLastLineBlock(String bchName, int msgType, int lineCode) throws SQLException { + try(Connection c=db.getConnection()){ return getLastLineBlock(c,bchName,msgType,lineCode); } + } + public List listRangeByNumber(String bchName,int from,int to)throws SQLException{try(Connection c=db.getConnection()){return listRangeByNumber(c,bchName,from,to);} } public List listRangeByNumber(Connection c,String bchName,int from,int to)throws SQLException{ - String sql=baseSelect()+" WHERE bch_name=? AND block_number>=? AND block_number<=? ORDER BY block_number ASC"; + String sql=baseSelect()+" WHERE login=? AND fork_number=? AND block_number>=? AND block_number<=? ORDER BY block_number ASC"; List out=new ArrayList<>(); - try(PreparedStatement ps=c.prepareStatement(sql)){ps.setString(1,bchName);ps.setInt(2,from);ps.setInt(3,to);try(ResultSet rs=ps.executeQuery()){while(rs.next())out.add(mapRow(rs));}} + 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; } private static String baseSelect(){return """ - 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,data_item_id, + 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 @@ -139,15 +164,27 @@ public final class BlocksDAO { 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.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.setToBchName(rs.getString("to_bch_name")); e.setToBlockNumber((Integer)rs.getObject("to_block_number")); e.setToBlockHash(rs.getBytes("to_block_hash")); + 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);} diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/CanonicalChainResolver.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/CanonicalChainResolver.java new file mode 100644 index 00000000..fee899c3 --- /dev/null +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/CanonicalChainResolver.java @@ -0,0 +1,36 @@ +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)));} +} diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ChannelNameStateDAO.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ChannelNameStateDAO.java index d9076c99..f24e3e0f 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ChannelNameStateDAO.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ChannelNameStateDAO.java @@ -28,11 +28,11 @@ public final class ChannelNameStateDAO { String sql = """ SELECT 1 FROM channel_names_state - WHERE owner_bch_name = ? AND channel_type_code = ? AND slug = ? + WHERE LOWER(owner_login) = LOWER(?) AND channel_type_code = ? AND slug = ? LIMIT 1 """; try (PreparedStatement ps = c.prepareStatement(sql)) { - ps.setString(1, ownerBchName); + ps.setString(1, loginOf(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 owner_bch_name = ? AND channel_root_block_number = ? + WHERE LOWER(owner_login)=LOWER(?) 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.getOwnerBlockchainName()); + ps.setString(7, entry.getOwnerLogin()); ps.setInt(8, entry.getChannelRootBlockNumber()); ps.executeUpdate(); } @@ -120,10 +120,31 @@ 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 owner_bch_name=? AND channel_root_block_number=? LIMIT 1"; + 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, ownerBchName); + ps.setString(1, loginOf(ownerBchName)); ps.setInt(2, rootBlockNumber); try (ResultSet rs = ps.executeQuery()) { return rs.next() ? rs.getString(1) : null; @@ -131,4 +152,5 @@ public final class ChannelNameStateDAO { } } + private static String loginOf(String bch){ if(bch==null)return ""; int d=bch.lastIndexOf('-'); return d>0?bch.substring(0,d):bch; } } diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ChannelReadStateDAO.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ChannelReadStateDAO.java index 14ddb017..44c2227c 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ChannelReadStateDAO.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ChannelReadStateDAO.java @@ -39,12 +39,12 @@ public final class ChannelReadStateDAO { 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 owner_bch_name=? AND channel_name=? + 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, ownerBchName); + ps.setString(2, loginFromChainName(ownerBchName)); ps.setString(3, channelName); try (ResultSet rs = ps.executeQuery()) { if (!rs.next()) return null; @@ -74,12 +74,13 @@ public final class ChannelReadStateDAO { JOIN connections_state cs ON LOWER(cs.login)=LOWER(crs.viewer_login) AND cs.rel_type=30 - AND cs.to_bch_name=cns.owner_bch_name + 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 cns.owner_bch_name=crs.owner_bch_name + 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)) { @@ -101,10 +102,10 @@ public final class ChannelReadStateDAO { JOIN connections_state cs ON LOWER(cs.login)=LOWER(?) AND cs.rel_type=? - AND cs.to_bch_name=cns.owner_bch_name + 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 cns.owner_bch_name=? + WHERE LOWER(cns.owner_login)=LOWER(?) AND cns.slug=? AND cns.channel_type_code=1 LIMIT 1 @@ -112,7 +113,7 @@ public final class ChannelReadStateDAO { try (PreparedStatement ps = c.prepareStatement(sql)) { ps.setString(1, viewerLogin); ps.setInt(2, followRelType); - ps.setString(3, ownerBchName); + ps.setString(3, loginFromChainName(ownerBchName)); ps.setString(4, channelName); try (ResultSet rs = ps.executeQuery()) { return rs.next(); @@ -124,11 +125,11 @@ public final class ChannelReadStateDAO { String sql = """ SELECT slug FROM channel_names_state - WHERE owner_bch_name=? AND channel_root_block_number=? AND channel_type_code=1 + 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, ownerBchName); + ps.setString(1, loginFromChainName(ownerBchName)); ps.setInt(2, rootBlockNumber); try (ResultSet rs = ps.executeQuery()) { return rs.next() ? rs.getString("slug") : null; @@ -141,11 +142,11 @@ public final class ChannelReadStateDAO { String sql = """ SELECT channel_root_block_number FROM channel_names_state - WHERE owner_bch_name=? AND slug=? AND channel_type_code=1 + WHERE LOWER(owner_login)=LOWER(?) AND slug=? AND channel_type_code=1 LIMIT 1 """; try (PreparedStatement ps = c.prepareStatement(sql)) { - ps.setString(1, ownerBchName); + ps.setString(1, loginFromChainName(ownerBchName)); ps.setString(2, channelName); try (ResultSet rs = ps.executeQuery()) { return rs.next() ? rs.getInt("channel_root_block_number") : null; @@ -157,11 +158,11 @@ public final class ChannelReadStateDAO { String sql = """ SELECT owner_login FROM channel_names_state - WHERE owner_bch_name=? AND slug=? AND channel_type_code=1 + WHERE LOWER(owner_login)=LOWER(?) AND slug=? AND channel_type_code=1 LIMIT 1 """; try (PreparedStatement ps = c.prepareStatement(sql)) { - ps.setString(1, ownerBchName); + ps.setString(1, loginFromChainName(ownerBchName)); ps.setString(2, channelName); try (ResultSet rs = ps.executeQuery()) { return rs.next() ? rs.getString("owner_login") : null; @@ -189,9 +190,10 @@ public final class ChannelReadStateDAO { read_count, unread_count, read_updated_at_ms, client_key, read_signature, updated_at_ms ) VALUES (?, ?, ?, ?, ?, 0, ?, ?, ?, ?) - ON CONFLICT (viewer_login, owner_bch_name, channel_name) + 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 - @@ -209,7 +211,7 @@ public final class ChannelReadStateDAO { try (PreparedStatement ps = c.prepareStatement(sql)) { ps.setString(1, viewerLogin); ps.setString(2, ownerLogin); - ps.setString(3, ownerBchName); + ps.setString(3, loginFromChainName(ownerBchName)); ps.setString(4, channelName); ps.setLong(5, Math.max(0L, readCount)); ps.setLong(6, readUpdatedAtMs); @@ -244,7 +246,7 @@ public final class ChannelReadStateDAO { UPDATE channel_read_state crs SET unread_count = crs.unread_count + 1, updated_at_ms = ? - WHERE crs.owner_bch_name = ? + WHERE LOWER(crs.owner_login)=LOWER(?) AND crs.channel_name = ? AND LOWER(crs.viewer_login) <> LOWER(crs.owner_login) AND EXISTS ( @@ -253,10 +255,10 @@ public final class ChannelReadStateDAO { JOIN connections_state cs ON LOWER(cs.login)=LOWER(crs.viewer_login) AND cs.rel_type=? - AND cs.to_bch_name=cns.owner_bch_name + 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 cns.owner_bch_name=crs.owner_bch_name + WHERE LOWER(cns.owner_login)=LOWER(crs.owner_login) AND cns.slug=crs.channel_name AND cns.channel_type_code=1 ) @@ -265,7 +267,7 @@ public final class ChannelReadStateDAO { List affected = new ArrayList<>(); try (PreparedStatement ps = c.prepareStatement(sql)) { ps.setLong(1, nowMs); - ps.setString(2, ownerBchName); + ps.setString(2, loginFromChainName(ownerBchName)); ps.setString(3, channelName); ps.setInt(4, followRelType); try (ResultSet rs = ps.executeQuery()) { @@ -282,17 +284,51 @@ public final class ChannelReadStateDAO { DELETE FROM channel_read_state crs USING channel_names_state cns WHERE LOWER(crs.viewer_login)=LOWER(?) - AND crs.owner_bch_name=? - AND cns.owner_bch_name=crs.owner_bch_name + 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, ownerBchName); + 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; } + } diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ConnectionsStateDAO.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ConnectionsStateDAO.java index dc6c01a6..3f980b4f 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ConnectionsStateDAO.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ConnectionsStateDAO.java @@ -39,19 +39,14 @@ public final class ConnectionsStateDAO { */ public List listOutgoingByRelTypeCanonical(Connection c, String loginAnyCase, int relType) throws SQLException { String sql = """ - SELECT COALESCE(u_login.login, u_bch.login, cs.to_login) AS friend_login + SELECT COALESCE(u_login.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"), - CurrentUsersSql.usersSubquery("u_bch") - ); + """.formatted(CurrentUsersSql.usersSubquery("u_login")); List out = new ArrayList<>(); try (PreparedStatement ps = c.prepareStatement(sql)) { @@ -73,19 +68,14 @@ public final class ConnectionsStateDAO { 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 = ? AND ( LOWER(cs.to_login) = LOWER(?) - OR LOWER(COALESCE(u_login.login, u_bch.login, cs.to_login)) = LOWER(?) + OR LOWER(COALESCE(u_login.login, cs.to_login)) = LOWER(?) ) LIMIT 1 - """.formatted( - CurrentUsersSql.usersSubquery("u_login"), - CurrentUsersSql.usersSubquery("u_bch") - ); + """.formatted(CurrentUsersSql.usersSubquery("u_login")); try (PreparedStatement ps = c.prepareStatement(sql)) { ps.setString(1, loginAnyCase); ps.setInt(2, relType); @@ -104,33 +94,12 @@ 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) - 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 = ? + LEFT JOIN %s ON LOWER(u_actor.login)=LOWER(cs.login) + WHERE LOWER(cs.to_login)=LOWER(?) AND cs.rel_type=? ORDER BY friend_login - """.formatted( - CurrentUsersSql.usersSubquery("u_actor"), - CurrentUsersSql.usersSubquery("u_target") - ); - - List 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); - } - } - } + """.formatted(CurrentUsersSql.usersSubquery("u_actor")); + List 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);}}} return out; } @@ -189,21 +158,17 @@ public final class ConnectionsStateDAO { } String sql = """ - 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 + 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 """; try (PreparedStatement ps = c.prepareStatement(sql)) { ps.setString(1, login); ps.setInt(2, relType); 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); + if (toBlockNumber == null) ps.setNull(4, java.sql.Types.INTEGER); else ps.setInt(4, toBlockNumber); + ps.setBytes(5, toBlockHash); ps.executeUpdate(); } } diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/KeyRotationCandidateBlocksDAO.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/KeyRotationCandidateBlocksDAO.java new file mode 100644 index 00000000..f1afc953 --- /dev/null +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/KeyRotationCandidateBlocksDAO.java @@ -0,0 +1,250 @@ +package shine.db.dao; + +import shine.db.DbController; +import shine.db.entities.KeyRotationCandidateBlockEntry; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +/** Хранилище candidate-блоков будущего fork во время ротации ключей. */ +public final class KeyRotationCandidateBlocksDAO { + private static volatile KeyRotationCandidateBlocksDAO instance; + private final DbController db = DbController.getInstance(); + + private KeyRotationCandidateBlocksDAO() { } + + public static KeyRotationCandidateBlocksDAO getInstance() { + if (instance == null) { + synchronized (KeyRotationCandidateBlocksDAO.class) { + if (instance == null) instance = new KeyRotationCandidateBlocksDAO(); + } + } + return instance; + } + + /** + * Идемпотентно сохраняет один candidate-блок. + * Повтор того же blockNumber допустим только при полном совпадении hash и DataItem id. + */ + public KeyRotationCandidateBlockEntry insertOrGet(Connection c, KeyRotationCandidateBlockEntry entry) throws SQLException { + KeyRotationCandidateBlockEntry existing = getByNumber(c, entry.getRotationSessionId(), entry.getBlockNumber()); + if (existing != null) { + if (Arrays.equals(existing.getBlockHash(), entry.getBlockHash()) + && Arrays.equals(existing.getDataItemId(), entry.getDataItemId())) { + return existing; + } + throw new SQLException("Candidate block conflict at number=" + entry.getBlockNumber()); + } + + String sql = """ + INSERT INTO key_rotation_candidate_blocks ( + rotation_session_id, login, candidate_blockchain_name, + block_number, block_hash, data_item_id, block_bytes, + arweave_publish_pending, arweave_published_at_ms, created_at_ms + ) VALUES (?, ?, ?, ?, ?, ?, ?, TRUE, NULL, ?) + """; + try (PreparedStatement ps = c.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) { + int i = 1; + ps.setLong(i++, entry.getRotationSessionId()); + ps.setString(i++, entry.getLogin()); + ps.setString(i++, entry.getCandidateBlockchainName()); + ps.setInt(i++, entry.getBlockNumber()); + ps.setBytes(i++, entry.getBlockHash()); + ps.setBytes(i++, entry.getDataItemId()); + ps.setBytes(i++, entry.getBlockBytes()); + ps.setLong(i++, entry.getCreatedAtMs()); + ps.executeUpdate(); + try (ResultSet keys = ps.getGeneratedKeys()) { + if (!keys.next()) throw new SQLException("candidate block insert returned no id"); + entry.setId(keys.getLong(1)); + } + } catch (SQLException insertFailure) { + // Конкурирующий повтор из другой сессии мог успеть вставиться между SELECT и INSERT. + KeyRotationCandidateBlockEntry raced = getByNumber(c, entry.getRotationSessionId(), entry.getBlockNumber()); + if (raced != null + && Arrays.equals(raced.getBlockHash(), entry.getBlockHash()) + && Arrays.equals(raced.getDataItemId(), entry.getDataItemId())) { + return raced; + } + throw insertFailure; + } + entry.setArweavePublishPending(true); + return entry; + } + + public KeyRotationCandidateBlockEntry getByNumber(Connection c, long sessionId, int blockNumber) throws SQLException { + try (PreparedStatement ps = c.prepareStatement(""" + SELECT * FROM key_rotation_candidate_blocks + WHERE rotation_session_id = ? AND block_number = ? + """)) { + ps.setLong(1, sessionId); + ps.setInt(2, blockNumber); + try (ResultSet rs = ps.executeQuery()) { + return rs.next() ? map(rs) : null; + } + } + } + + public int countStored(Connection c, long sessionId) throws SQLException { + try (PreparedStatement ps = c.prepareStatement(""" + SELECT COUNT(*) FROM key_rotation_candidate_blocks WHERE rotation_session_id = ? + """)) { + ps.setLong(1, sessionId); + try (ResultSet rs = ps.executeQuery()) { + rs.next(); + return rs.getInt(1); + } + } + } + + public int countPublished(Connection c, long sessionId) throws SQLException { + try (PreparedStatement ps = c.prepareStatement(""" + SELECT COUNT(*) FROM key_rotation_candidate_blocks + WHERE rotation_session_id = ? AND arweave_publish_pending = FALSE + """)) { + ps.setLong(1, sessionId); + try (ResultSet rs = ps.executeQuery()) { + rs.next(); + return rs.getInt(1); + } + } + } + + /** Все candidate-блоки одной ротации в строгом порядке block_number. */ + public List listBySession(Connection c, long sessionId) throws SQLException { + try (PreparedStatement ps = c.prepareStatement(""" + SELECT * FROM key_rotation_candidate_blocks + WHERE rotation_session_id = ? + ORDER BY block_number + """)) { + ps.setLong(1, sessionId); + List out = new ArrayList<>(); + try (ResultSet rs = ps.executeQuery()) { + while (rs.next()) out.add(map(rs)); + } + return out; + } + } + + /** Возвращает ещё не опубликованный candidate DataItem для быстрой Turbo-попытки. */ + public KeyRotationCandidateBlockEntry getPendingArweaveByDataItemId(byte[] dataItemId) throws SQLException { + if (dataItemId == null || dataItemId.length != 32) return null; + try (Connection c = db.getConnection(); + PreparedStatement ps = c.prepareStatement(""" + SELECT * FROM key_rotation_candidate_blocks + WHERE data_item_id = ? AND arweave_publish_pending = TRUE + LIMIT 1 + """)) { + ps.setBytes(1, dataItemId); + try (ResultSet rs = ps.executeQuery()) { return rs.next() ? map(rs) : null; } + } + } + + /** Candidate-блоки имеют приоритет перед обычной очередью publisher-а. */ + public List listPendingArweave(int limit) throws SQLException { + if (limit <= 0) return List.of(); + try (Connection c = db.getConnection(); + PreparedStatement ps = c.prepareStatement(""" + SELECT * FROM key_rotation_candidate_blocks + WHERE arweave_publish_pending = TRUE + ORDER BY id + LIMIT ? + """)) { + ps.setInt(1, limit); + List out = new ArrayList<>(); + try (ResultSet rs = ps.executeQuery()) { + while (rs.next()) out.add(map(rs)); + } + return out; + } + } + + /** + * Помечает DataItem опубликованными и синхронизирует progress_current ротации + * с реальным количеством DataItem, подтверждённых publisher-ом. + */ + public void markArweavePublished(List dataItemIds, long publishedAtMs) throws SQLException { + if (dataItemIds == null || dataItemIds.isEmpty()) return; + try (Connection c = db.getConnection()) { + boolean oldAutoCommit = c.getAutoCommit(); + c.setAutoCommit(false); + try { + java.util.Set sessions = new java.util.HashSet<>(); + try (PreparedStatement find = c.prepareStatement(""" + SELECT rotation_session_id + FROM key_rotation_candidate_blocks + WHERE data_item_id = ? + """)) { + for (byte[] id : dataItemIds) { + find.setBytes(1, id); + try (ResultSet rs = find.executeQuery()) { + if (rs.next()) sessions.add(rs.getLong(1)); + } + } + } + + try (PreparedStatement ps = c.prepareStatement(""" + UPDATE key_rotation_candidate_blocks + SET arweave_publish_pending = FALSE, + arweave_published_at_ms = COALESCE(arweave_published_at_ms, ?) + WHERE data_item_id = ? + """)) { + for (byte[] id : dataItemIds) { + ps.setLong(1, publishedAtMs); + ps.setBytes(2, id); + ps.addBatch(); + } + ps.executeBatch(); + } + + try (PreparedStatement progress = c.prepareStatement(""" + UPDATE key_rotation_sessions s + SET progress_current = LEAST(s.progress_total, ( + SELECT COUNT(*)::INTEGER + FROM key_rotation_candidate_blocks b + WHERE b.rotation_session_id = s.id + AND b.arweave_publish_pending = FALSE + )), + updated_at_ms = ? + WHERE s.id = ? AND s.status = 'COPYING_CHAIN' + """)) { + for (Long sessionId : sessions) { + progress.setLong(1, publishedAtMs); + progress.setLong(2, sessionId); + progress.addBatch(); + } + progress.executeBatch(); + } + c.commit(); + } catch (Exception e) { + c.rollback(); + if (e instanceof SQLException sql) throw sql; + throw new SQLException("Failed to mark candidate DataItems published", e); + } finally { + c.setAutoCommit(oldAutoCommit); + } + } + } + + private static KeyRotationCandidateBlockEntry map(ResultSet rs) throws SQLException { + KeyRotationCandidateBlockEntry e = new KeyRotationCandidateBlockEntry(); + e.setId(rs.getLong("id")); + e.setRotationSessionId(rs.getLong("rotation_session_id")); + e.setLogin(rs.getString("login")); + e.setCandidateBlockchainName(rs.getString("candidate_blockchain_name")); + e.setBlockNumber(rs.getInt("block_number")); + e.setBlockHash(rs.getBytes("block_hash")); + e.setDataItemId(rs.getBytes("data_item_id")); + e.setBlockBytes(rs.getBytes("block_bytes")); + e.setArweavePublishPending(rs.getBoolean("arweave_publish_pending")); + e.setArweavePublishedAtMs((Long) rs.getObject("arweave_published_at_ms")); + e.setCreatedAtMs(rs.getLong("created_at_ms")); + return e; + } +} diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/KeyRotationSessionsDAO.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/KeyRotationSessionsDAO.java new file mode 100644 index 00000000..7a41afa1 --- /dev/null +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/KeyRotationSessionsDAO.java @@ -0,0 +1,612 @@ +package shine.db.dao; + +import shine.db.DbController; +import shine.db.entities.KeyRotationSessionEntry; +import shine.db.entities.KeyRotationStatus; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Statement; + +/** + * DAO для серверной машины смены ключей. + * + * Все методы изменения статуса синхронно обновляют и key_rotation_sessions, + * и solana_user_pda_current.rotation_status / rotation_session_id. + */ +public final class KeyRotationSessionsDAO { + + private static volatile KeyRotationSessionsDAO instance; + private final DbController db = DbController.getInstance(); + + private KeyRotationSessionsDAO() { } + + public static KeyRotationSessionsDAO getInstance() { + if (instance == null) { + synchronized (KeyRotationSessionsDAO.class) { + if (instance == null) instance = new KeyRotationSessionsDAO(); + } + } + return instance; + } + + /** + * Атомарно создаёт первую серверную запись ротации сразу в COPYING_CHAIN. + * PREPARING в БД отсутствует: до этого момента всё является локальным UI-состоянием. + */ + public KeyRotationSessionEntry createCopyingSession(KeyRotationSessionEntry entry) throws SQLException { + validateNewSession(entry); + try (Connection c = db.getConnection()) { + boolean oldAutoCommit = c.getAutoCommit(); + c.setAutoCommit(false); + try { + KeyRotationSessionEntry created = createCopyingSession(c, entry); + c.commit(); + return created; + } catch (Exception e) { + c.rollback(); + if (e instanceof SQLException sql) throw sql; + throw new SQLException("Failed to create key rotation session", e); + } finally { + c.setAutoCommit(oldAutoCommit); + } + } + } + + public KeyRotationSessionEntry createCopyingSession(Connection c, KeyRotationSessionEntry entry) throws SQLException { + validateNewSession(entry); + + String currentStatus; + try (PreparedStatement ps = c.prepareStatement(""" + SELECT rotation_status + FROM solana_user_pda_current + WHERE login = ? + FOR UPDATE + """)) { + ps.setString(1, entry.getLogin()); + try (ResultSet rs = ps.executeQuery()) { + if (!rs.next()) throw new SQLException("Unknown login for key rotation: " + entry.getLogin()); + currentStatus = rs.getString(1); + } + } + + if (!KeyRotationStatus.NONE.name().equals(currentStatus)) { + throw new SQLException("Key rotation already active for login=" + entry.getLogin() + ", status=" + currentStatus); + } + + long now = entry.getCreatedAtMs() > 0 ? entry.getCreatedAtMs() : System.currentTimeMillis(); + entry.setCreatedAtMs(now); + entry.setUpdatedAtMs(now); + entry.setStatus(KeyRotationStatus.COPYING_CHAIN); + if (entry.getComment() == null) entry.setComment(""); + if (entry.getWalletMigrationStatus() == null) entry.setWalletMigrationStatus("PENDING"); + if (entry.getMessageMigrationStatus() == null) entry.setMessageMigrationStatus("PENDING"); + + String sql = """ + INSERT INTO key_rotation_sessions ( + login, status, + source_blockchain_name, candidate_blockchain_name, + old_root_key, old_blockchain_key, old_client_key, + new_root_key, new_blockchain_key, new_client_key, + fork_from_block, fork_from_hash, + source_tip_block, source_tip_hash, + reason_code, comment, + progress_current, progress_total, + pda_rotation_signature, + wallet_migration_status, message_migration_status, + last_error, last_error_at_ms, retry_count, + created_at_ms, updated_at_ms, completed_at_ms, aborted_at_ms + ) VALUES ( + ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? + ) + """; + + long id; + try (PreparedStatement ps = c.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) { + int i = 1; + ps.setString(i++, entry.getLogin()); + ps.setString(i++, entry.getStatus().name()); + ps.setString(i++, entry.getSourceBlockchainName()); + ps.setString(i++, entry.getCandidateBlockchainName()); + ps.setString(i++, entry.getOldRootKey()); + ps.setString(i++, entry.getOldBlockchainKey()); + ps.setString(i++, entry.getOldClientKey()); + ps.setString(i++, entry.getNewRootKey()); + ps.setString(i++, entry.getNewBlockchainKey()); + ps.setString(i++, entry.getNewClientKey()); + ps.setInt(i++, entry.getForkFromBlock()); + ps.setBytes(i++, entry.getForkFromHash()); + ps.setInt(i++, entry.getSourceTipBlock()); + ps.setBytes(i++, entry.getSourceTipHash()); + ps.setShort(i++, entry.getReasonCode()); + ps.setString(i++, entry.getComment()); + ps.setInt(i++, entry.getProgressCurrent()); + ps.setInt(i++, entry.getProgressTotal()); + ps.setString(i++, entry.getPdaRotationSignature()); + ps.setString(i++, entry.getWalletMigrationStatus()); + ps.setString(i++, entry.getMessageMigrationStatus()); + ps.setString(i++, entry.getLastError()); + if (entry.getLastErrorAtMs() == null) ps.setNull(i++, java.sql.Types.BIGINT); else ps.setLong(i++, entry.getLastErrorAtMs()); + ps.setInt(i++, entry.getRetryCount()); + ps.setLong(i++, entry.getCreatedAtMs()); + ps.setLong(i++, entry.getUpdatedAtMs()); + if (entry.getCompletedAtMs() == null) ps.setNull(i++, java.sql.Types.BIGINT); else ps.setLong(i++, entry.getCompletedAtMs()); + if (entry.getAbortedAtMs() == null) ps.setNull(i++, java.sql.Types.BIGINT); else ps.setLong(i++, entry.getAbortedAtMs()); + ps.executeUpdate(); + try (ResultSet keys = ps.getGeneratedKeys()) { + if (!keys.next()) throw new SQLException("key_rotation_sessions insert returned no id"); + id = keys.getLong(1); + } + } + + try (PreparedStatement ps = c.prepareStatement(""" + UPDATE solana_user_pda_current + SET rotation_status = ?, rotation_session_id = ? + WHERE login = ? AND rotation_status = 'NONE' + """)) { + ps.setString(1, KeyRotationStatus.COPYING_CHAIN.name()); + ps.setLong(2, id); + ps.setString(3, entry.getLogin()); + if (ps.executeUpdate() != 1) { + throw new SQLException("Failed to attach key rotation session to login=" + entry.getLogin()); + } + } + + entry.setId(id); + return entry; + } + + public KeyRotationSessionEntry getById(long id) throws SQLException { + try (Connection c = db.getConnection()) { + return getById(c, id); + } + } + + public KeyRotationSessionEntry getById(Connection c, long id) throws SQLException { + try (PreparedStatement ps = c.prepareStatement(selectBase() + " WHERE id = ?")) { + ps.setLong(1, id); + try (ResultSet rs = ps.executeQuery()) { + return rs.next() ? mapRow(rs) : null; + } + } + } + + public KeyRotationSessionEntry getActiveByLogin(String login) throws SQLException { + try (Connection c = db.getConnection()) { + return getActiveByLogin(c, login); + } + } + + public KeyRotationSessionEntry getActiveByLogin(Connection c, String login) throws SQLException { + try (PreparedStatement ps = c.prepareStatement(selectBase() + """ + WHERE login = ? + AND status NOT IN ('COMPLETE', 'ABORTED') + ORDER BY id DESC + LIMIT 1 + """)) { + ps.setString(1, login); + try (ResultSet rs = ps.executeQuery()) { + return rs.next() ? mapRow(rs) : null; + } + } + } + + /** Возвращает несколько сессий одного состояния для фоновых workers. */ + public java.util.List listByStatus(KeyRotationStatus status, int limit) throws SQLException { + if (status == null || status == KeyRotationStatus.NONE) return java.util.List.of(); + int safeLimit = Math.max(1, Math.min(limit, 100)); + try (Connection c = db.getConnection(); + PreparedStatement ps = c.prepareStatement(selectBase() + """ + WHERE status = ? + ORDER BY updated_at_ms, id + LIMIT ? + """)) { + ps.setString(1, status.name()); + ps.setInt(2, safeLimit); + java.util.List out = new java.util.ArrayList<>(); + try (ResultSet rs = ps.executeQuery()) { + while (rs.next()) out.add(mapRow(rs)); + } + return out; + } + } + + /** + * Атомарный переход state machine. Смена статуса выполняется только из expected. + */ + public KeyRotationSessionEntry transition(long id, + KeyRotationStatus expected, + KeyRotationStatus next) throws SQLException { + if (expected == null || next == null || !expected.canTransitionTo(next)) { + throw new IllegalArgumentException("Forbidden key rotation transition: " + expected + " -> " + next); + } + + try (Connection c = db.getConnection()) { + boolean oldAutoCommit = c.getAutoCommit(); + c.setAutoCommit(false); + try { + KeyRotationSessionEntry current = getByIdForUpdate(c, id); + if (current == null) throw new SQLException("Unknown key rotation session id=" + id); + if (current.getStatus() != expected) { + throw new SQLException("Key rotation status mismatch: expected=" + expected + ", actual=" + current.getStatus()); + } + + long now = System.currentTimeMillis(); + Long completed = current.getCompletedAtMs(); + if (next == KeyRotationStatus.COMPLETE) completed = now; + Long aborted = current.getAbortedAtMs(); + if (next == KeyRotationStatus.ABORTED) aborted = now; + + try (PreparedStatement ps = c.prepareStatement(""" + UPDATE key_rotation_sessions + SET status = ?, updated_at_ms = ?, completed_at_ms = ?, aborted_at_ms = ? + WHERE id = ? AND status = ? + """)) { + ps.setString(1, next.name()); + ps.setLong(2, now); + if (completed == null) ps.setNull(3, java.sql.Types.BIGINT); else ps.setLong(3, completed); + if (aborted == null) ps.setNull(4, java.sql.Types.BIGINT); else ps.setLong(4, aborted); + ps.setLong(5, id); + ps.setString(6, expected.name()); + if (ps.executeUpdate() != 1) throw new SQLException("Concurrent key rotation transition for id=" + id); + } + + KeyRotationStatus userStatus = next.userStatus(); + try (PreparedStatement ps = c.prepareStatement(""" + UPDATE solana_user_pda_current + SET rotation_status = ?, rotation_session_id = ? + WHERE login = ? AND rotation_session_id = ? + """)) { + ps.setString(1, userStatus.name()); + if (userStatus == KeyRotationStatus.NONE) ps.setNull(2, java.sql.Types.BIGINT); else ps.setLong(2, id); + ps.setString(3, current.getLogin()); + ps.setLong(4, id); + if (ps.executeUpdate() != 1) throw new SQLException("Rotation session is not attached to login=" + current.getLogin()); + } + + // Candidate-копии нужны только пока ротация активна. В Arweave они уже опубликованы, + // а в PostgreSQL после COMPLETE/ABORTED временные строки больше не нужны. + if (next.isTerminalSessionStatus()) { + try (PreparedStatement ps = c.prepareStatement( + "DELETE FROM key_rotation_candidate_blocks WHERE rotation_session_id = ?")) { + ps.setLong(1, id); + ps.executeUpdate(); + } + } + + c.commit(); + current.setStatus(next); + current.setUpdatedAtMs(now); + current.setCompletedAtMs(completed); + current.setAbortedAtMs(aborted); + return current; + } catch (Exception e) { + c.rollback(); + if (e instanceof SQLException sql) throw sql; + throw new SQLException("Failed key rotation transition", e); + } finally { + c.setAutoCommit(oldAutoCommit); + } + } + } + + public void updateProgress(long id, int current, int total) throws SQLException { + if (current < 0 || total < 0 || current > total) { + throw new IllegalArgumentException("Invalid rotation progress: " + current + "/" + total); + } + try (Connection c = db.getConnection(); + PreparedStatement ps = c.prepareStatement(""" + UPDATE key_rotation_sessions + SET progress_current = ?, progress_total = ?, updated_at_ms = ? + WHERE id = ? AND status = 'COPYING_CHAIN' + """)) { + ps.setInt(1, current); + ps.setInt(2, total); + ps.setLong(3, System.currentTimeMillis()); + ps.setLong(4, id); + if (ps.executeUpdate() != 1) throw new SQLException("Rotation progress can only be updated in COPYING_CHAIN, id=" + id); + } + } + + /** + * Атомарно фиксирует tx signature и переводит CHAIN_READY -> ROTATING_PDA. + * Это точка, после которой Abort запрещён: отправленная Solana-транзакция может подтвердиться позже. + */ + public KeyRotationSessionEntry beginPdaRotation(long id, String signature) throws SQLException { + if (signature == null || signature.isBlank()) throw new IllegalArgumentException("signature is empty"); + try (Connection c = db.getConnection()) { + boolean oldAutoCommit = c.getAutoCommit(); + c.setAutoCommit(false); + try { + KeyRotationSessionEntry current = getByIdForUpdate(c, id); + if (current == null) throw new SQLException("Unknown key rotation session id=" + id); + if (current.getStatus() != KeyRotationStatus.CHAIN_READY) { + throw new SQLException("PDA rotation requires CHAIN_READY, actual=" + current.getStatus()); + } + long now = System.currentTimeMillis(); + try (PreparedStatement ps = c.prepareStatement(""" + UPDATE key_rotation_sessions + SET status = 'ROTATING_PDA', pda_rotation_signature = ?, updated_at_ms = ?, + last_error = NULL, last_error_at_ms = NULL + WHERE id = ? AND status = 'CHAIN_READY' + """)) { + ps.setString(1, signature); + ps.setLong(2, now); + ps.setLong(3, id); + if (ps.executeUpdate() != 1) throw new SQLException("Concurrent PDA rotation start for id=" + id); + } + try (PreparedStatement ps = c.prepareStatement(""" + UPDATE solana_user_pda_current + SET rotation_status = 'ROTATING_PDA', rotation_session_id = ? + WHERE login = ? AND rotation_session_id = ? AND rotation_status = 'CHAIN_READY' + """)) { + ps.setLong(1, id); + ps.setString(2, current.getLogin()); + ps.setLong(3, id); + if (ps.executeUpdate() != 1) throw new SQLException("Rotation session is not attached to login=" + current.getLogin()); + } + c.commit(); + current.setStatus(KeyRotationStatus.ROTATING_PDA); + current.setPdaRotationSignature(signature); + current.setUpdatedAtMs(now); + current.setLastError(null); + current.setLastErrorAtMs(null); + return current; + } catch (Exception e) { + c.rollback(); + if (e instanceof SQLException sql) throw sql; + throw new SQLException("Failed to begin PDA rotation", e); + } finally { + c.setAutoCommit(oldAutoCommit); + } + } + } + + /** + * Если Solana sync уже записал в current-PDA весь ожидаемый новый набор ключей, + * атомарно переводит ROTATING_PDA -> PDA_ROTATED. Иначе возвращает null. + */ + public KeyRotationSessionEntry tryMarkPdaRotatedFromCurrentState(long id) throws SQLException { + try (Connection c = db.getConnection()) { + boolean oldAutoCommit = c.getAutoCommit(); + c.setAutoCommit(false); + try { + KeyRotationSessionEntry current = getByIdForUpdate(c, id); + if (current == null || current.getStatus() != KeyRotationStatus.ROTATING_PDA) { + c.rollback(); + return current != null && current.getStatus() == KeyRotationStatus.PDA_ROTATED ? current : null; + } + + String root; + String blockchain; + String client; + String blockchainName; + try (PreparedStatement ps = c.prepareStatement(""" + SELECT root_key, blockchain_key, client_key, blockchain_name + FROM solana_user_pda_current + WHERE login = ? + FOR UPDATE + """)) { + ps.setString(1, current.getLogin()); + try (ResultSet rs = ps.executeQuery()) { + if (!rs.next()) { c.rollback(); return null; } + root = shine.db.KeyEncodingUtil.normalizeKeyToBase64_32(rs.getString("root_key")); + blockchain = shine.db.KeyEncodingUtil.normalizeKeyToBase64_32(rs.getString("blockchain_key")); + client = shine.db.KeyEncodingUtil.normalizeKeyToBase64_32(rs.getString("client_key")); + blockchainName = rs.getString("blockchain_name"); + } + } + + if (!current.getNewRootKey().equals(root) + || !current.getNewBlockchainKey().equals(blockchain) + || !current.getNewClientKey().equals(client) + || !current.getCandidateBlockchainName().equals(blockchainName)) { + c.rollback(); + return null; + } + + long now = System.currentTimeMillis(); + try (PreparedStatement ps = c.prepareStatement(""" + UPDATE key_rotation_sessions + SET status = 'PDA_ROTATED', updated_at_ms = ?, last_error = NULL, last_error_at_ms = NULL + WHERE id = ? AND status = 'ROTATING_PDA' + """)) { + ps.setLong(1, now); + ps.setLong(2, id); + if (ps.executeUpdate() != 1) throw new SQLException("Concurrent PDA rotation confirm for id=" + id); + } + try (PreparedStatement ps = c.prepareStatement(""" + UPDATE solana_user_pda_current + SET rotation_status = 'PDA_ROTATED', rotation_session_id = ? + WHERE login = ? AND rotation_session_id = ? AND rotation_status = 'ROTATING_PDA' + """)) { + ps.setLong(1, id); + ps.setString(2, current.getLogin()); + ps.setLong(3, id); + if (ps.executeUpdate() != 1) throw new SQLException("Rotation session is not attached to current PDA login=" + current.getLogin()); + } + c.commit(); + current.setStatus(KeyRotationStatus.PDA_ROTATED); + current.setUpdatedAtMs(now); + current.setLastError(null); + current.setLastErrorAtMs(null); + return current; + } catch (Exception e) { + c.rollback(); + if (e instanceof SQLException sql) throw sql; + throw new SQLException("Failed to confirm rotated PDA", e); + } finally { + c.setAutoCommit(oldAutoCommit); + } + } + } + + public void setPdaRotationSignature(long id, String signature) throws SQLException { + try (Connection c = db.getConnection(); + PreparedStatement ps = c.prepareStatement(""" + UPDATE key_rotation_sessions + SET pda_rotation_signature = ?, updated_at_ms = ? + WHERE id = ? AND status = 'ROTATING_PDA' + """)) { + ps.setString(1, signature); + ps.setLong(2, System.currentTimeMillis()); + ps.setLong(3, id); + if (ps.executeUpdate() != 1) throw new SQLException("PDA signature requires ROTATING_PDA, id=" + id); + } + } + + /** + * Фиксирует результат необязательного этапа wallet/DM. + * Имя колонки выбирается только из закрытого списка — внешние значения в SQL не подставляются. + */ + public void setMigrationSubStatus(long id, String column, String value) throws SQLException { + String safeColumn = switch (String.valueOf(column)) { + case "wallet_migration_status" -> "wallet_migration_status"; + case "message_migration_status" -> "message_migration_status"; + default -> throw new IllegalArgumentException("Unsupported migration status column: " + column); + }; + String safeValue = switch (String.valueOf(value)) { + case "PENDING", "COMPLETE", "SKIPPED", "NOT_IMPLEMENTED" -> String.valueOf(value); + default -> throw new IllegalArgumentException("Unsupported migration status value: " + value); + }; + try (Connection c = db.getConnection(); + PreparedStatement ps = c.prepareStatement( + "UPDATE key_rotation_sessions SET " + safeColumn + " = ?, updated_at_ms = ? WHERE id = ?")) { + ps.setString(1, safeValue); + ps.setLong(2, System.currentTimeMillis()); + ps.setLong(3, id); + if (ps.executeUpdate() != 1) throw new SQLException("Unknown key rotation session id=" + id); + } + } + + public void recordError(long id, String error) throws SQLException { + long now = System.currentTimeMillis(); + try (Connection c = db.getConnection(); + PreparedStatement ps = c.prepareStatement(""" + UPDATE key_rotation_sessions + SET last_error = ?, last_error_at_ms = ?, retry_count = retry_count + 1, updated_at_ms = ? + WHERE id = ? AND status NOT IN ('COMPLETE', 'ABORTED') + """)) { + ps.setString(1, error); + ps.setLong(2, now); + ps.setLong(3, now); + ps.setLong(4, id); + if (ps.executeUpdate() != 1) throw new SQLException("Cannot record error for inactive rotation id=" + id); + } + } + + public void clearError(long id) throws SQLException { + try (Connection c = db.getConnection(); + PreparedStatement ps = c.prepareStatement(""" + UPDATE key_rotation_sessions + SET last_error = NULL, last_error_at_ms = NULL, updated_at_ms = ? + WHERE id = ? + """)) { + ps.setLong(1, System.currentTimeMillis()); + ps.setLong(2, id); + ps.executeUpdate(); + } + } + + private KeyRotationSessionEntry getByIdForUpdate(Connection c, long id) throws SQLException { + try (PreparedStatement ps = c.prepareStatement(selectBase() + " WHERE id = ? FOR UPDATE")) { + ps.setLong(1, id); + try (ResultSet rs = ps.executeQuery()) { + return rs.next() ? mapRow(rs) : null; + } + } + } + + private static String selectBase() { + return """ + SELECT + id, login, status, + source_blockchain_name, candidate_blockchain_name, + old_root_key, old_blockchain_key, old_client_key, + new_root_key, new_blockchain_key, new_client_key, + fork_from_block, fork_from_hash, + source_tip_block, source_tip_hash, + reason_code, comment, + progress_current, progress_total, + pda_rotation_signature, + wallet_migration_status, message_migration_status, + last_error, last_error_at_ms, retry_count, + created_at_ms, updated_at_ms, completed_at_ms, aborted_at_ms + FROM key_rotation_sessions + """; + } + + private static KeyRotationSessionEntry mapRow(ResultSet rs) throws SQLException { + KeyRotationSessionEntry e = new KeyRotationSessionEntry(); + e.setId(rs.getLong("id")); + e.setLogin(rs.getString("login")); + e.setStatus(KeyRotationStatus.valueOf(rs.getString("status"))); + e.setSourceBlockchainName(rs.getString("source_blockchain_name")); + e.setCandidateBlockchainName(rs.getString("candidate_blockchain_name")); + e.setOldRootKey(rs.getString("old_root_key")); + e.setOldBlockchainKey(rs.getString("old_blockchain_key")); + e.setOldClientKey(rs.getString("old_client_key")); + e.setNewRootKey(rs.getString("new_root_key")); + e.setNewBlockchainKey(rs.getString("new_blockchain_key")); + e.setNewClientKey(rs.getString("new_client_key")); + e.setForkFromBlock(rs.getInt("fork_from_block")); + e.setForkFromHash(rs.getBytes("fork_from_hash")); + e.setSourceTipBlock(rs.getInt("source_tip_block")); + e.setSourceTipHash(rs.getBytes("source_tip_hash")); + e.setReasonCode(rs.getShort("reason_code")); + e.setComment(rs.getString("comment")); + e.setProgressCurrent(rs.getInt("progress_current")); + e.setProgressTotal(rs.getInt("progress_total")); + e.setPdaRotationSignature(rs.getString("pda_rotation_signature")); + e.setWalletMigrationStatus(rs.getString("wallet_migration_status")); + e.setMessageMigrationStatus(rs.getString("message_migration_status")); + e.setLastError(rs.getString("last_error")); + long lastErrorAt = rs.getLong("last_error_at_ms"); + e.setLastErrorAtMs(rs.wasNull() ? null : lastErrorAt); + e.setRetryCount(rs.getInt("retry_count")); + e.setCreatedAtMs(rs.getLong("created_at_ms")); + e.setUpdatedAtMs(rs.getLong("updated_at_ms")); + long completed = rs.getLong("completed_at_ms"); + e.setCompletedAtMs(rs.wasNull() ? null : completed); + long aborted = rs.getLong("aborted_at_ms"); + e.setAbortedAtMs(rs.wasNull() ? null : aborted); + return e; + } + + private static void validateNewSession(KeyRotationSessionEntry e) { + if (e == null) throw new IllegalArgumentException("entry is null"); + if (blank(e.getLogin())) throw new IllegalArgumentException("login is required"); + if (blank(e.getSourceBlockchainName()) || blank(e.getCandidateBlockchainName())) { + throw new IllegalArgumentException("source/candidate blockchain names are required"); + } + if (blank(e.getOldRootKey()) || blank(e.getOldBlockchainKey()) || blank(e.getOldClientKey()) + || blank(e.getNewRootKey()) || blank(e.getNewBlockchainKey()) || blank(e.getNewClientKey())) { + throw new IllegalArgumentException("all old/new public keys are required"); + } + if (e.getForkFromHash() == null || e.getForkFromHash().length != 32) { + throw new IllegalArgumentException("forkFromHash must be 32 bytes"); + } + if (e.getSourceTipHash() == null || e.getSourceTipHash().length != 32) { + throw new IllegalArgumentException("sourceTipHash must be 32 bytes"); + } + if (e.getForkFromBlock() < 0 || e.getSourceTipBlock() < e.getForkFromBlock()) { + throw new IllegalArgumentException("invalid fork/source tip block numbers"); + } + if (e.getReasonCode() < 1 || e.getReasonCode() > 4) { + throw new IllegalArgumentException("reasonCode must be 1..4"); + } + String comment = e.getComment() == null ? "" : e.getComment(); + if (comment.getBytes(java.nio.charset.StandardCharsets.UTF_8).length > 1024) { + throw new IllegalArgumentException("comment must be <= 1024 UTF-8 bytes"); + } + if (e.getProgressCurrent() < 0 || e.getProgressTotal() < e.getProgressCurrent()) { + throw new IllegalArgumentException("invalid initial progress"); + } + } + + private static boolean blank(String value) { + return value == null || value.isBlank(); + } +} diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/SignedMessagesDAO.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/SignedMessagesDAO.java index 988f6c72..1c83c1bf 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/SignedMessagesDAO.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/SignedMessagesDAO.java @@ -377,6 +377,7 @@ public final class SignedMessagesDAO { String peerLogin, long beforeTimeMs, String beforeMessageKey, + long reencryptedBeforeMs, int limit ) throws Exception { try (Connection c = db.getConnection()) { @@ -398,6 +399,7 @@ public final class SignedMessagesDAO { OR time_ms < ? OR (time_ms = ? AND (? = '' OR message_key < ?)) ) + AND (? <= 0 OR (created_at_ms <= ? AND reencrypted_at_ms < ?)) ORDER BY time_ms DESC, message_key DESC LIMIT ? """.formatted(messagesTable()); @@ -413,7 +415,10 @@ public final class SignedMessagesDAO { ps.setLong(8, beforeTimeMs); ps.setString(9, beforeMessageKey == null ? "" : beforeMessageKey); ps.setString(10, beforeMessageKey == null ? "" : beforeMessageKey); - ps.setInt(11, limit); + ps.setLong(11, reencryptedBeforeMs); + ps.setLong(12, reencryptedBeforeMs); + ps.setLong(13, reencryptedBeforeMs); + ps.setInt(14, limit); try (ResultSet rs = ps.executeQuery()) { while (rs.next()) out.add(mapRow(rs)); } @@ -422,6 +427,102 @@ public final class SignedMessagesDAO { } } + public long countMessagesNeedingReencryption(String login, long reencryptedBeforeMs) throws SQLException { + if (reencryptedBeforeMs <= 0) return 0; + try (Connection c = db.getConnection(); + PreparedStatement ps = c.prepareStatement(""" + SELECT COUNT(*) + FROM %s + WHERE LOWER(target_login) = LOWER(?) + AND message_type IN (1, 2) + AND created_at_ms <= ? + AND reencrypted_at_ms < ? + """.formatted(messagesTable()))) { + ps.setString(1, login); + ps.setLong(2, reencryptedBeforeMs); + ps.setLong(3, reencryptedBeforeMs); + try (ResultSet rs = ps.executeQuery()) { + return rs.next() ? rs.getLong(1) : 0L; + } + } + } + + /** Обновляет только уже существующую локальную type=1/2 копию при key rotation. */ + public ApplyStatus upsertReencryptedLocalCopy(SignedMessageEntry next) throws Exception { + return withBusyRetry(() -> { + try (Connection c = db.getConnection()) { + boolean oldAutoCommit = c.getAutoCommit(); + c.setAutoCommit(false); + try { + SignedMessageEntry current = getByMessageKey(c, next.getMessageKey()); + if (current == null) { c.rollback(); return ApplyStatus.DUPLICATE_OR_OLDER; } + if (current.getMessageType() != next.getMessageType() + || current.getTimeMs() != next.getTimeMs() + || current.getNonce() != next.getNonce() + || current.getRevisionTimeMs() != next.getRevisionTimeMs() + || !current.getFromLogin().equalsIgnoreCase(next.getFromLogin()) + || !current.getToLogin().equalsIgnoreCase(next.getToLogin()) + || !current.getBaseKey().equals(next.getBaseKey()) + || next.getReencryptedAtMs() <= current.getReencryptedAtMs()) { + c.rollback(); + return ApplyStatus.DUPLICATE_OR_OLDER; + } + updateReencryptedLocalCopy(c, next); + DmDialogStateDAO.getInstance().refreshConversationPair(c, next.getFromLogin(), next.getToLogin()); + c.commit(); + return ApplyStatus.APPLIED; + } catch (Exception e) { + try { c.rollback(); } catch (Exception ignored) {} + throw e; + } finally { + c.setAutoCommit(oldAutoCommit); + } + } + }); + } + + /** + * Перезаписывает только криптографическую локальную копию сообщения при key rotation. + * Исторические metadata (created_at_ms/source_api/origin_session_id/read_at_ms) сохраняются. + */ + private void updateReencryptedLocalCopy(Connection c, SignedMessageEntry next) throws SQLException { + String sql = """ + UPDATE %s + SET reencrypted_at_ms = ?, + raw_block = ? + WHERE message_key = ? + AND reencrypted_at_ms < ? + """.formatted(messagesTable()); + try (PreparedStatement ps = c.prepareStatement(sql)) { + ps.setLong(1, next.getReencryptedAtMs()); + ps.setBytes(2, next.getRawBlock()); + ps.setString(3, next.getMessageKey()); + ps.setLong(4, next.getReencryptedAtMs()); + int changed = ps.executeUpdate(); + if (changed != 1) { + throw new SQLException("Reencrypted local copy was not updated: " + next.getMessageKey()); + } + } + } + + private SignedMessageEntry getByMessageKey(Connection c, String messageKey) throws Exception { + String sql = """ + SELECT + message_key, base_key, target_login, from_login, to_login, + time_ms, nonce, message_type, revision_time_ms, reencrypted_at_ms, + raw_block, created_at_ms, source_api, origin_session_id, + receipt_ref_base_key, receipt_ref_type, read_at_ms + FROM %s + WHERE message_key = ? + """.formatted(messagesTable()); + try (PreparedStatement ps = c.prepareStatement(sql)) { + ps.setString(1, messageKey); + try (ResultSet rs = ps.executeQuery()) { + return rs.next() ? mapRow(rs) : null; + } + } + } + public SyncBatch listSyncBatch( String ownerLogin, long afterStoredAtMs, diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/SolanaUserPdaCurrentDAO.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/SolanaUserPdaCurrentDAO.java index e98d887e..2b6704bf 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/SolanaUserPdaCurrentDAO.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/SolanaUserPdaCurrentDAO.java @@ -37,6 +37,27 @@ public final class SolanaUserPdaCurrentDAO { } } + + public SolanaUserPdaCurrentEntry getByLogin(String login) throws SQLException { + String sql = """ + SELECT + login, + blockchain_name, + blockchain_key, + paid_limit_bytes + FROM solana_user_pda_current + WHERE LOWER(login) = LOWER(?) + LIMIT 1 + """; + try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(sql)) { + ps.setString(1, login); + try (ResultSet rs = ps.executeQuery()) { + if (!rs.next()) return null; + return mapRow(rs); + } + } + } + public SolanaUserPdaCurrentEntry getByBlockchainName(Connection c, String blockchainName) throws SQLException { String sql = """ SELECT @@ -73,6 +94,7 @@ public final class SolanaUserPdaCurrentDAO { FROM solana_user_pda_current u CROSS JOIN LATERAL jsonb_array_elements(COALESCE(NULLIF(u.blockchain_forks_json, ''), '[]')::jsonb) AS fork_item(value) WHERE fork_item.value ->> 'blockchainKey' = ? + AND ((fork_item.value ->> 'forkIndex')::integer + 1) BETWEEN 1 AND 999 LIMIT 1 """; try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(sql)) { diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/SubscriptionsDAO.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/SubscriptionsDAO.java index 83882403..d050a27a 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/SubscriptionsDAO.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/SubscriptionsDAO.java @@ -106,11 +106,12 @@ public final class SubscriptionsDAO { WITH subs AS ( -- 1) FOLLOW-каналы SELECT - cs.to_login AS channel_login, - cs.to_bch_name AS channel_bch_name + cs.to_login AS channel_login, + cn.owner_bch_name AS channel_bch_name FROM connections_state cs - WHERE cs.login = ? - AND cs.rel_type = ? + 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 cs.login = ? AND cs.rel_type = ? UNION diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/UserProfileStateDAO.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/UserProfileStateDAO.java index 95105a46..b9ca0892 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/UserProfileStateDAO.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/dao/UserProfileStateDAO.java @@ -37,9 +37,8 @@ public final class UserProfileStateDAO { /** * Effective outgoing social relation with priority close_friend > friend > contact > none. * - * Use the canonical relation lookup instead of comparing only connections_state.to_login: - * older/current blocks may address a user by blockchain name, so a direct to_login-only - * query can incorrectly report "none" even when ListContacts/Connections sees the relation. + * Use the canonical relation lookup so all UI paths share the same normalized login matching. + * Stage 2 connections_state identity is logical and no longer contains a physical target fork. */ public String getEffectiveRelationType(Connection c, String ownerLogin, String targetLogin) throws SQLException { if (ownerLogin == null || ownerLogin.isBlank() || targetLogin == null || targetLogin.isBlank()) return "none"; @@ -112,31 +111,48 @@ public final class UserProfileStateDAO { return out; } - public List listPublicChannels(Connection c, String login, String mode, int limit, int offset) throws SQLException { + public List listPublicChannels(Connection c, String login, String mode, boolean includeDeleted, int limit, int offset) throws SQLException { int safeLimit=Math.max(1,Math.min(limit<=0?100:limit,500)), safeOffset=Math.max(0,offset); String sql; if ("owned".equals(mode)) { sql=""" - SELECT cn.owner_login, cn.slug, cn.display_name, cn.ava_ar, cn.owner_bch_name, cn.channel_root_block_number, encode(cn.channel_root_block_hash,'hex') root_hash - FROM channel_names_state cn WHERE LOWER(cn.owner_login)=LOWER(?) AND cn.channel_type_code=1 + SELECT cn.owner_login, cn.slug, cn.display_name, cn.ava_ar, cn.ava_sha256, cn.owner_bch_name, + cn.channel_root_block_number, encode(cn.channel_root_block_hash,'hex') root_hash, + cn.is_deleted, cn.deleted_at_ms, cn.deleted_block_number + FROM channel_names_state cn + WHERE LOWER(cn.owner_login)=LOWER(?) AND cn.channel_type_code=1 AND (? OR NOT cn.is_deleted) ORDER BY cn.display_name, cn.slug LIMIT ? OFFSET ? """; } else if ("following".equals(mode)) { sql=""" - SELECT DISTINCT cn.owner_login, cn.slug, cn.display_name, cn.ava_ar, cn.owner_bch_name, cn.channel_root_block_number, encode(cn.channel_root_block_hash,'hex') root_hash - FROM connections_state cs JOIN channel_names_state cn ON cn.owner_bch_name=cs.to_bch_name 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 AND cn.channel_type_code=1 + SELECT DISTINCT cn.owner_login, cn.slug, cn.display_name, cn.ava_ar, cn.ava_sha256, cn.owner_bch_name, + cn.channel_root_block_number, encode(cn.channel_root_block_hash,'hex') root_hash, + cn.is_deleted, cn.deleted_at_ms, cn.deleted_block_number + 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 AND cn.channel_type_code=1 AND (? OR NOT cn.is_deleted) ORDER BY cn.display_name, cn.slug LIMIT ? OFFSET ? """; } else throw new IllegalArgumentException("Unsupported channel mode: "+mode); List out=new ArrayList<>(); - try(PreparedStatement ps=c.prepareStatement(sql)){ ps.setString(1,login);ps.setInt(2,safeLimit);ps.setInt(3,safeOffset); - try(ResultSet rs=ps.executeQuery()){while(rs.next())out.add(new ChannelCard(rs.getString("owner_login"),rs.getString("slug"),rs.getString("display_name"),rs.getString("ava_ar"),rs.getString("owner_bch_name"),rs.getInt("channel_root_block_number"),rs.getString("root_hash")));}} + try(PreparedStatement ps=c.prepareStatement(sql)){ + ps.setString(1,login); ps.setBoolean(2,includeDeleted); ps.setInt(3,safeLimit); ps.setInt(4,safeOffset); + try(ResultSet rs=ps.executeQuery()){ + while(rs.next()) out.add(new ChannelCard( + rs.getString("owner_login"), rs.getString("slug"), rs.getString("display_name"), rs.getString("ava_ar"), rs.getString("ava_sha256"), + rs.getString("owner_bch_name"), rs.getInt("channel_root_block_number"), rs.getString("root_hash"), + rs.getBoolean("is_deleted"), rs.getLong("deleted_at_ms"), (Integer) rs.getObject("deleted_block_number") + )); + } + } return out; } private static ProfileCard map(ResultSet rs)throws SQLException{return new ProfileCard(rs.getString("login"),rs.getString("first_name"),rs.getString("last_name"),rs.getString("ava_ar"),rs.getString("account_role"),rs.getString("shine_status"));} public record ProfileCard(String login,String firstName,String lastName,String avatarAr,String accountRole,String shineStatus){} public record RelationCard(String login,String firstName,String lastName,String avatarAr,String accountRole,String shineStatus,boolean primaryConfirmed,boolean shineConfirmed,String relationType,int primaryConfirmationsCount,int shineConfirmationsCount){} - public record ChannelCard(String ownerLogin,String slug,String displayName,String avatarAr,String ownerBlockchainName,int rootBlockNumber,String rootBlockHashHex){} + public record ChannelCard(String ownerLogin,String slug,String displayName,String avatarAr,String avatarSha256,String ownerBlockchainName,int rootBlockNumber,String rootBlockHashHex,boolean deleted,long deletedAtMs,Integer deletedBlockNumber){} } diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/entities/BlockEntry.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/entities/BlockEntry.java index 965de4f9..4b4e4fd1 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/entities/BlockEntry.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/entities/BlockEntry.java @@ -4,7 +4,7 @@ package shine.db.entities; * Запись блока (таблица blocks) — обновлённая модель под новый формат. * * Храним: - * - login, bch_name (как было в проекте, чтобы не ломать общую БД) + * - login + fork_number (physical fork identity; bch_name is derived only for display/API) * - block_number (глобальный номер в этой цепочке) * - block_bytes (полный блок: preimage + signature) * - block_hash (32 байта вычисленный SHA-256(preimage)) @@ -21,7 +21,7 @@ package shine.db.entities; public class BlockEntry { private String login; - private String bchName; + private int forkNumber; private int blockNumber; @@ -31,7 +31,7 @@ public class BlockEntry { private byte[] blockBytes; private String toLogin; - private String toBchName; + private Integer toForkNumber; private Integer toBlockNumber; private byte[] toBlockHash; @@ -55,8 +55,14 @@ public class BlockEntry { public String getLogin() { return login; } public void setLogin(String login) { this.login = login; } - public String getBchName() { return bchName; } - public void setBchName(String bchName) { this.bchName = bchName; } + public int getForkNumber() { return forkNumber; } + public void setForkNumber(int forkNumber) { if (forkNumber < 1 || forkNumber > 999) throw new IllegalArgumentException("forkNumber must be 1..999"); this.forkNumber = forkNumber; } + + /** Compatibility/display helper. DB does not store bch_name anymore. */ + public String getBchName() { + if (login == null || login.isBlank() || forkNumber < 1 || forkNumber > 999) return null; + return login + "-" + String.format("%03d", forkNumber); + } public int getBlockNumber() { return blockNumber; } public void setBlockNumber(int blockNumber) { this.blockNumber = blockNumber; } @@ -73,8 +79,14 @@ public class BlockEntry { public String getToLogin() { return toLogin; } public void setToLogin(String toLogin) { this.toLogin = toLogin; } - public String getToBchName() { return toBchName; } - public void setToBchName(String toBchName) { this.toBchName = toBchName; } + /** Derived historical display value only; never part of target identity. */ + public String getToBchName() { + if (toLogin == null || toLogin.isBlank() || toForkNumber == null || toForkNumber < 1 || toForkNumber > 999) return null; + return toLogin + "-" + String.format("%03d", toForkNumber); + } + + public Integer getToForkNumber() { return toForkNumber; } + public void setToForkNumber(Integer toForkNumber) { if (toForkNumber != null && (toForkNumber < 1 || toForkNumber > 999)) throw new IllegalArgumentException("toForkNumber must be 1..999"); this.toForkNumber = toForkNumber; } public Integer getToBlockNumber() { return toBlockNumber; } public void setToBlockNumber(Integer toBlockNumber) { this.toBlockNumber = toBlockNumber; } diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/entities/BlockchainStateEntry.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/entities/BlockchainStateEntry.java index eb6cd0e5..96f0a857 100644 --- a/SHiNE-server/shine-server-db/src/main/java/shine/db/entities/BlockchainStateEntry.java +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/entities/BlockchainStateEntry.java @@ -16,8 +16,8 @@ import java.util.Base64; */ public final class BlockchainStateEntry { - private String blockchainName; private String login; + private int forkNumber; private String blockchainKey; // Base64(32) @@ -31,8 +31,22 @@ public final class BlockchainStateEntry { public BlockchainStateEntry() {} - public String getBlockchainName() { return blockchainName; } - public void setBlockchainName(String blockchainName) { this.blockchainName = blockchainName; } + public String getBlockchainName() { + if (login == null || login.isBlank() || forkNumber < 1 || forkNumber > 999) return null; + return login + "-" + String.format("%03d", forkNumber); + } + /** Compatibility setter for API/import code; DB stores login + forkNumber. */ + public void setBlockchainName(String blockchainName) { + if (blockchainName == null) return; + int dash=blockchainName.lastIndexOf('-'); + if (dash <= 0 || blockchainName.length()-dash-1 != 3) throw new IllegalArgumentException("Bad blockchainName: "+blockchainName); + int parsedFork=Integer.parseInt(blockchainName.substring(dash+1)); + if (parsedFork < 1 || parsedFork > 999) throw new IllegalArgumentException("forkNumber must be 1..999"); + this.login=blockchainName.substring(0,dash); + this.forkNumber=parsedFork; + } + public int getForkNumber() { return forkNumber; } + public void setForkNumber(int forkNumber) { if (forkNumber < 1 || forkNumber > 999) throw new IllegalArgumentException("forkNumber must be 1..999"); this.forkNumber = forkNumber; } public String getLogin() { return login; } public void setLogin(String login) { this.login = login; } diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/entities/KeyRotationCandidateBlockEntry.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/entities/KeyRotationCandidateBlockEntry.java new file mode 100644 index 00000000..5ffa3729 --- /dev/null +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/entities/KeyRotationCandidateBlockEntry.java @@ -0,0 +1,45 @@ +package shine.db.entities; + +/** + * Candidate-блок будущего fork во время смены ключей. + * + * Эти записи намеренно не попадают в обычную таблицу blocks и поэтому + * не влияют на лайки, ответы, каналы и другие materialized state до + * финального переключения активного fork. + */ +public final class KeyRotationCandidateBlockEntry { + private long id; + private long rotationSessionId; + private String login; + private String candidateBlockchainName; + private int blockNumber; + private byte[] blockHash; + private byte[] dataItemId; + private byte[] blockBytes; + private boolean arweavePublishPending; + private Long arweavePublishedAtMs; + private long createdAtMs; + + public long getId() { return id; } + public void setId(long id) { this.id = id; } + public long getRotationSessionId() { return rotationSessionId; } + public void setRotationSessionId(long rotationSessionId) { this.rotationSessionId = rotationSessionId; } + public String getLogin() { return login; } + public void setLogin(String login) { this.login = login; } + public String getCandidateBlockchainName() { return candidateBlockchainName; } + public void setCandidateBlockchainName(String candidateBlockchainName) { this.candidateBlockchainName = candidateBlockchainName; } + public int getBlockNumber() { return blockNumber; } + public void setBlockNumber(int blockNumber) { this.blockNumber = blockNumber; } + public byte[] getBlockHash() { return blockHash; } + public void setBlockHash(byte[] blockHash) { this.blockHash = blockHash; } + public byte[] getDataItemId() { return dataItemId; } + public void setDataItemId(byte[] dataItemId) { this.dataItemId = dataItemId; } + public byte[] getBlockBytes() { return blockBytes; } + public void setBlockBytes(byte[] blockBytes) { this.blockBytes = blockBytes; } + public boolean isArweavePublishPending() { return arweavePublishPending; } + public void setArweavePublishPending(boolean arweavePublishPending) { this.arweavePublishPending = arweavePublishPending; } + public Long getArweavePublishedAtMs() { return arweavePublishedAtMs; } + public void setArweavePublishedAtMs(Long arweavePublishedAtMs) { this.arweavePublishedAtMs = arweavePublishedAtMs; } + public long getCreatedAtMs() { return createdAtMs; } + public void setCreatedAtMs(long createdAtMs) { this.createdAtMs = createdAtMs; } +} diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/entities/KeyRotationSessionEntry.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/entities/KeyRotationSessionEntry.java new file mode 100644 index 00000000..b8235f25 --- /dev/null +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/entities/KeyRotationSessionEntry.java @@ -0,0 +1,96 @@ +package shine.db.entities; + +/** + * Публичное/runtime-состояние одной смены ключей. + * Приватные ключи и пароли в этой сущности не хранятся никогда. + */ +public final class KeyRotationSessionEntry { + private long id; + private String login; + private KeyRotationStatus status; + private String sourceBlockchainName; + private String candidateBlockchainName; + private String oldRootKey; + private String oldBlockchainKey; + private String oldClientKey; + private String newRootKey; + private String newBlockchainKey; + private String newClientKey; + private int forkFromBlock; + private byte[] forkFromHash; + private int sourceTipBlock; + private byte[] sourceTipHash; + private short reasonCode; + private String comment; + private int progressCurrent; + private int progressTotal; + private String pdaRotationSignature; + private String walletMigrationStatus; + private String messageMigrationStatus; + private String lastError; + private Long lastErrorAtMs; + private int retryCount; + private long createdAtMs; + private long updatedAtMs; + private Long completedAtMs; + private Long abortedAtMs; + + public long getId() { return id; } + public void setId(long id) { this.id = id; } + public String getLogin() { return login; } + public void setLogin(String login) { this.login = login; } + public KeyRotationStatus getStatus() { return status; } + public void setStatus(KeyRotationStatus status) { this.status = status; } + public String getSourceBlockchainName() { return sourceBlockchainName; } + public void setSourceBlockchainName(String sourceBlockchainName) { this.sourceBlockchainName = sourceBlockchainName; } + public String getCandidateBlockchainName() { return candidateBlockchainName; } + public void setCandidateBlockchainName(String candidateBlockchainName) { this.candidateBlockchainName = candidateBlockchainName; } + public String getOldRootKey() { return oldRootKey; } + public void setOldRootKey(String oldRootKey) { this.oldRootKey = oldRootKey; } + public String getOldBlockchainKey() { return oldBlockchainKey; } + public void setOldBlockchainKey(String oldBlockchainKey) { this.oldBlockchainKey = oldBlockchainKey; } + public String getOldClientKey() { return oldClientKey; } + public void setOldClientKey(String oldClientKey) { this.oldClientKey = oldClientKey; } + public String getNewRootKey() { return newRootKey; } + public void setNewRootKey(String newRootKey) { this.newRootKey = newRootKey; } + public String getNewBlockchainKey() { return newBlockchainKey; } + public void setNewBlockchainKey(String newBlockchainKey) { this.newBlockchainKey = newBlockchainKey; } + public String getNewClientKey() { return newClientKey; } + public void setNewClientKey(String newClientKey) { this.newClientKey = newClientKey; } + public int getForkFromBlock() { return forkFromBlock; } + public void setForkFromBlock(int forkFromBlock) { this.forkFromBlock = forkFromBlock; } + public byte[] getForkFromHash() { return forkFromHash; } + public void setForkFromHash(byte[] forkFromHash) { this.forkFromHash = forkFromHash; } + public int getSourceTipBlock() { return sourceTipBlock; } + public void setSourceTipBlock(int sourceTipBlock) { this.sourceTipBlock = sourceTipBlock; } + public byte[] getSourceTipHash() { return sourceTipHash; } + public void setSourceTipHash(byte[] sourceTipHash) { this.sourceTipHash = sourceTipHash; } + public short getReasonCode() { return reasonCode; } + public void setReasonCode(short reasonCode) { this.reasonCode = reasonCode; } + public String getComment() { return comment; } + public void setComment(String comment) { this.comment = comment; } + public int getProgressCurrent() { return progressCurrent; } + public void setProgressCurrent(int progressCurrent) { this.progressCurrent = progressCurrent; } + public int getProgressTotal() { return progressTotal; } + public void setProgressTotal(int progressTotal) { this.progressTotal = progressTotal; } + public String getPdaRotationSignature() { return pdaRotationSignature; } + public void setPdaRotationSignature(String pdaRotationSignature) { this.pdaRotationSignature = pdaRotationSignature; } + public String getWalletMigrationStatus() { return walletMigrationStatus; } + public void setWalletMigrationStatus(String walletMigrationStatus) { this.walletMigrationStatus = walletMigrationStatus; } + public String getMessageMigrationStatus() { return messageMigrationStatus; } + public void setMessageMigrationStatus(String messageMigrationStatus) { this.messageMigrationStatus = messageMigrationStatus; } + public String getLastError() { return lastError; } + public void setLastError(String lastError) { this.lastError = lastError; } + public Long getLastErrorAtMs() { return lastErrorAtMs; } + public void setLastErrorAtMs(Long lastErrorAtMs) { this.lastErrorAtMs = lastErrorAtMs; } + public int getRetryCount() { return retryCount; } + public void setRetryCount(int retryCount) { this.retryCount = retryCount; } + public long getCreatedAtMs() { return createdAtMs; } + public void setCreatedAtMs(long createdAtMs) { this.createdAtMs = createdAtMs; } + public long getUpdatedAtMs() { return updatedAtMs; } + public void setUpdatedAtMs(long updatedAtMs) { this.updatedAtMs = updatedAtMs; } + public Long getCompletedAtMs() { return completedAtMs; } + public void setCompletedAtMs(Long completedAtMs) { this.completedAtMs = completedAtMs; } + public Long getAbortedAtMs() { return abortedAtMs; } + public void setAbortedAtMs(Long abortedAtMs) { this.abortedAtMs = abortedAtMs; } +} diff --git a/SHiNE-server/shine-server-db/src/main/java/shine/db/entities/KeyRotationStatus.java b/SHiNE-server/shine-server-db/src/main/java/shine/db/entities/KeyRotationStatus.java new file mode 100644 index 00000000..dc049188 --- /dev/null +++ b/SHiNE-server/shine-server-db/src/main/java/shine/db/entities/KeyRotationStatus.java @@ -0,0 +1,71 @@ +package shine.db.entities; + +import java.util.EnumSet; +import java.util.Set; + +/** + * Состояния серверной машины смены ключей. + * + * NONE используется только в solana_user_pda_current.rotation_status. + * COMPLETE/ABORTED остаются в истории key_rotation_sessions, после чего + * пользователь снова получает rotation_status=NONE. + */ +public enum KeyRotationStatus { + NONE, + COPYING_CHAIN, + CHAIN_READY, + ROTATING_PDA, + PDA_ROTATED, + REBUILDING_SERVER, + WALLET_MIGRATION, + MESSAGE_MIGRATION, + FINALIZING, + COMPLETE, + ABORTED; + + public boolean isTerminalSessionStatus() { + return this == COMPLETE || this == ABORTED; + } + + public boolean isUserActiveStatus() { + return this != NONE && !isTerminalSessionStatus(); + } + + /** + * Допустимые переходы одной ротации. + * Abort сознательно разрешён только до начала ROTATING_PDA: после отправки + * Solana-транзакции нельзя надёжно знать, не будет ли она подтверждена позже. + */ + public boolean canTransitionTo(KeyRotationStatus next) { + if (next == null) return false; + return switch (this) { + case COPYING_CHAIN -> EnumSet.of(CHAIN_READY, ABORTED).contains(next); + case CHAIN_READY -> EnumSet.of(ROTATING_PDA, ABORTED).contains(next); + case ROTATING_PDA -> next == PDA_ROTATED; + case PDA_ROTATED -> next == REBUILDING_SERVER; + case REBUILDING_SERVER -> next == WALLET_MIGRATION; + case WALLET_MIGRATION -> next == MESSAGE_MIGRATION; + case MESSAGE_MIGRATION -> next == FINALIZING; + case FINALIZING -> next == COMPLETE; + case NONE, COMPLETE, ABORTED -> false; + }; + } + + public static Set activeStatuses() { + return EnumSet.of( + COPYING_CHAIN, + CHAIN_READY, + ROTATING_PDA, + PDA_ROTATED, + REBUILDING_SERVER, + WALLET_MIGRATION, + MESSAGE_MIGRATION, + FINALIZING + ); + } + + /** Статус, который должен храниться у пользователя для данной session-state. */ + public KeyRotationStatus userStatus() { + return isTerminalSessionStatus() ? NONE : this; + } +} diff --git a/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v26.sql b/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v26.sql new file mode 100644 index 00000000..e3352475 --- /dev/null +++ b/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v26.sql @@ -0,0 +1,123 @@ +-- v26: серверная state machine смены ключей пользователя. +-- +-- Важно: +-- - rotation_status / rotation_session_id являются ЛОКАЛЬНЫМ runtime-состоянием сервера, +-- а не полями Solana PDA; +-- - Solana sync не должен перезаписывать эти колонки при upsert PDA; +-- - приватные ключи здесь никогда не хранятся, только публичные ключи ротации. + +ALTER TABLE solana_user_pda_current + ADD COLUMN IF NOT EXISTS rotation_status TEXT NOT NULL DEFAULT 'NONE'; + +ALTER TABLE solana_user_pda_current + ADD COLUMN IF NOT EXISTS rotation_session_id BIGINT; + +ALTER TABLE solana_user_pda_current + DROP CONSTRAINT IF EXISTS chk_solana_user_pda_current_rotation_status; + +ALTER TABLE solana_user_pda_current + ADD CONSTRAINT chk_solana_user_pda_current_rotation_status CHECK ( + rotation_status IN ( + 'NONE', + 'COPYING_CHAIN', + 'CHAIN_READY', + 'ROTATING_PDA', + 'PDA_ROTATED', + 'REBUILDING_SERVER', + 'WALLET_MIGRATION', + 'MESSAGE_MIGRATION', + 'FINALIZING' + ) + ); + +CREATE INDEX IF NOT EXISTS idx_solana_user_pda_current_rotation_active + ON solana_user_pda_current(rotation_status) + WHERE rotation_status <> 'NONE'; + +CREATE TABLE IF NOT EXISTS key_rotation_sessions ( + id BIGSERIAL PRIMARY KEY, + login TEXT NOT NULL REFERENCES solana_user_pda_current(login) ON DELETE CASCADE, + status TEXT NOT NULL CHECK ( + status IN ( + 'COPYING_CHAIN', + 'CHAIN_READY', + 'ROTATING_PDA', + 'PDA_ROTATED', + 'REBUILDING_SERVER', + 'WALLET_MIGRATION', + 'MESSAGE_MIGRATION', + 'FINALIZING', + 'COMPLETE', + 'ABORTED' + ) + ), + + source_blockchain_name TEXT NOT NULL, + candidate_blockchain_name TEXT NOT NULL, + + old_root_key TEXT NOT NULL, + old_blockchain_key TEXT NOT NULL, + old_client_key TEXT NOT NULL, + new_root_key TEXT NOT NULL, + new_blockchain_key TEXT NOT NULL, + new_client_key TEXT NOT NULL, + + fork_from_block INTEGER NOT NULL CHECK (fork_from_block >= 0), + fork_from_hash BYTEA NOT NULL CHECK (octet_length(fork_from_hash) = 32), + source_tip_block INTEGER NOT NULL CHECK (source_tip_block >= 0), + source_tip_hash BYTEA NOT NULL CHECK (octet_length(source_tip_hash) = 32), + + reason_code SMALLINT NOT NULL CHECK (reason_code BETWEEN 1 AND 4), + comment TEXT NOT NULL DEFAULT '' CHECK (octet_length(convert_to(comment, 'UTF8')) <= 1024), + + progress_current INTEGER NOT NULL DEFAULT 0 CHECK (progress_current >= 0), + progress_total INTEGER NOT NULL DEFAULT 0 CHECK (progress_total >= 0), + + pda_rotation_signature TEXT, + + wallet_migration_status TEXT NOT NULL DEFAULT 'PENDING' CHECK ( + wallet_migration_status IN ('PENDING', 'COMPLETE', 'SKIPPED', 'NOT_IMPLEMENTED') + ), + message_migration_status TEXT NOT NULL DEFAULT 'PENDING' CHECK ( + message_migration_status IN ('PENDING', 'COMPLETE', 'SKIPPED', 'NOT_IMPLEMENTED') + ), + + last_error TEXT, + last_error_at_ms BIGINT, + retry_count INTEGER NOT NULL DEFAULT 0 CHECK (retry_count >= 0), + + created_at_ms BIGINT NOT NULL, + updated_at_ms BIGINT NOT NULL, + completed_at_ms BIGINT, + aborted_at_ms BIGINT, + + CHECK (progress_current <= progress_total), + CHECK (fork_from_block <= source_tip_block) +); + +-- У одного login одновременно может существовать только одна незавершённая ротация. +CREATE UNIQUE INDEX IF NOT EXISTS uq_key_rotation_sessions_active_login + ON key_rotation_sessions(login) + WHERE status NOT IN ('COMPLETE', 'ABORTED'); + +CREATE INDEX IF NOT EXISTS idx_key_rotation_sessions_login_created + ON key_rotation_sessions(login, created_at_ms DESC); + +CREATE INDEX IF NOT EXISTS idx_key_rotation_sessions_status + ON key_rotation_sessions(status); + +-- Быстрый указатель из текущего пользователя на активную/последнюю runtime-сессию. +-- FK добавляется после создания key_rotation_sessions, чтобы не создавать циклический DDL порядок. +ALTER TABLE solana_user_pda_current + DROP CONSTRAINT IF EXISTS fk_solana_user_pda_current_rotation_session; + +ALTER TABLE solana_user_pda_current + ADD CONSTRAINT fk_solana_user_pda_current_rotation_session + FOREIGN KEY (rotation_session_id) + REFERENCES key_rotation_sessions(id) + ON DELETE SET NULL; + +UPDATE db_schema_version +SET schema_version = 26, + updated_at_ms = CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT) +WHERE id = 1; diff --git a/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v27.sql b/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v27.sql new file mode 100644 index 00000000..1c33e1e0 --- /dev/null +++ b/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v27.sql @@ -0,0 +1,31 @@ +BEGIN; + +CREATE TABLE IF NOT EXISTS key_rotation_candidate_blocks ( + id BIGSERIAL PRIMARY KEY, + rotation_session_id BIGINT NOT NULL REFERENCES key_rotation_sessions(id) ON DELETE CASCADE, + login TEXT NOT NULL, + candidate_blockchain_name TEXT NOT NULL, + block_number INTEGER NOT NULL CHECK (block_number >= 0), + block_hash BYTEA NOT NULL CHECK (octet_length(block_hash) = 32), + data_item_id BYTEA NOT NULL CHECK (octet_length(data_item_id) = 32), + block_bytes BYTEA NOT NULL, + arweave_publish_pending BOOLEAN NOT NULL DEFAULT TRUE, + arweave_published_at_ms BIGINT, + created_at_ms BIGINT NOT NULL, + UNIQUE (rotation_session_id, block_number), + UNIQUE (rotation_session_id, data_item_id) +); + +CREATE INDEX IF NOT EXISTS idx_key_rotation_candidate_blocks_pending + ON key_rotation_candidate_blocks(id) + WHERE arweave_publish_pending = TRUE; + +CREATE INDEX IF NOT EXISTS idx_key_rotation_candidate_blocks_session + ON key_rotation_candidate_blocks(rotation_session_id, block_number); + +UPDATE db_schema_version +SET schema_version = 27, + updated_at_ms = CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT) +WHERE id = 1; + +COMMIT; diff --git a/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v31.sql b/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v31.sql new file mode 100644 index 00000000..b834c029 --- /dev/null +++ b/SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v31.sql @@ -0,0 +1,32 @@ +BEGIN; + +ALTER TABLE channel_names_state + ADD COLUMN IF NOT EXISTS is_deleted BOOLEAN NOT NULL DEFAULT FALSE, + ADD COLUMN IF NOT EXISTS deleted_at_ms BIGINT NOT NULL DEFAULT 0, + ADD COLUMN IF NOT EXISTS deleted_block_number INTEGER; + +CREATE OR REPLACE FUNCTION shine_refresh_user_stats(p_login TEXT) RETURNS VOID LANGUAGE plpgsql AS $$ +DECLARE v_now BIGINT:=CAST(EXTRACT(EPOCH FROM clock_timestamp())*1000 AS BIGINT); +BEGIN + IF p_login IS NULL OR btrim(p_login)='' THEN RETURN; END IF; + INSERT INTO user_stats_state(login,owned_public_channels_count,following_users_count,following_channels_count,close_friends_count,friends_count, + primary_confirmations_received_count,primary_confirmations_given_count,shine_confirmations_received_count,shine_confirmations_given_count,updated_at_ms) + SELECT p_login, + (SELECT COUNT(*)::INT FROM channel_names_state cn WHERE LOWER(cn.owner_login)=LOWER(p_login) AND cn.channel_type_code=1 AND NOT cn.is_deleted), + (SELECT COUNT(DISTINCT LOWER(cs.to_login))::INT FROM connections_state cs WHERE LOWER(cs.login)=LOWER(p_login) AND cs.rel_type=30 AND cs.to_block_number=0), + (SELECT COUNT(*)::INT 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(p_login) AND cs.rel_type=30 AND cn.channel_type_code=1 AND NOT cn.is_deleted), + (SELECT COUNT(DISTINCT LOWER(cs.to_login))::INT FROM connections_state cs WHERE LOWER(cs.login)=LOWER(p_login) AND cs.rel_type=10), + (SELECT COUNT(DISTINCT LOWER(cs.to_login))::INT FROM connections_state cs WHERE LOWER(cs.login)=LOWER(p_login) AND cs.rel_type=14 AND NOT EXISTS(SELECT 1 FROM connections_state cf WHERE LOWER(cf.login)=LOWER(p_login) AND LOWER(cf.to_login)=LOWER(cs.to_login) AND cf.rel_type=10)), + (SELECT COUNT(DISTINCT LOWER(cs.login))::INT FROM connections_state cs WHERE LOWER(cs.to_login)=LOWER(p_login) AND cs.rel_type=80 AND shine_is_primary(cs.login) AND shine_target_accepts_primary_confirmation(p_login)), + (SELECT COUNT(DISTINCT LOWER(cs.to_login))::INT FROM connections_state cs WHERE LOWER(cs.login)=LOWER(p_login) AND cs.rel_type=80 AND shine_is_primary(p_login) AND shine_target_accepts_primary_confirmation(cs.to_login)), + (SELECT COUNT(DISTINCT LOWER(cs.login))::INT FROM connections_state cs WHERE LOWER(cs.to_login)=LOWER(p_login) AND cs.rel_type=70 AND shine_is_primary(cs.login) AND shine_is_shining(cs.login) AND shine_target_accepts_shine_confirmation(p_login)), + (SELECT COUNT(DISTINCT LOWER(cs.to_login))::INT FROM connections_state cs WHERE LOWER(cs.login)=LOWER(p_login) AND cs.rel_type=70 AND shine_is_primary(p_login) AND shine_is_shining(p_login) AND shine_target_accepts_shine_confirmation(cs.to_login)),v_now + ON CONFLICT(login) DO UPDATE SET owned_public_channels_count=EXCLUDED.owned_public_channels_count,following_users_count=EXCLUDED.following_users_count,following_channels_count=EXCLUDED.following_channels_count,close_friends_count=EXCLUDED.close_friends_count,friends_count=EXCLUDED.friends_count,primary_confirmations_received_count=EXCLUDED.primary_confirmations_received_count,primary_confirmations_given_count=EXCLUDED.primary_confirmations_given_count,shine_confirmations_received_count=EXCLUDED.shine_confirmations_received_count,shine_confirmations_given_count=EXCLUDED.shine_confirmations_given_count,updated_at_ms=EXCLUDED.updated_at_ms; +END $$; + +UPDATE db_schema_version +SET schema_version = 31, + updated_at_ms = CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT) +WHERE id = 1; + +COMMIT; diff --git a/SHiNE-server/shine-server-db/src/main/resources/postgres/schema_v1.sql b/SHiNE-server/shine-server-db/src/main/resources/postgres/schema_v1.sql index 17216960..fffbf864 100644 --- a/SHiNE-server/shine-server-db/src/main/resources/postgres/schema_v1.sql +++ b/SHiNE-server/shine-server-db/src/main/resources/postgres/schema_v1.sql @@ -1,5 +1,6 @@ --- SHiNE PostgreSQL runtime schema v1 --- Дата: 2026-07-28 +-- SHiNE PostgreSQL database format v2 / runtime schema revision 30 +-- Stage 2 baseline. This file is only for a NEW, EMPTY database. +-- Дата: 2026-09-29 -- -- Назначение: -- - поднять пустую PostgreSQL БД сервера SHiNE с нуля; @@ -15,14 +16,42 @@ BEGIN; +-- Safety guard: DB v2 is a fresh-baseline format, not an in-place migration. +DO $$ +BEGIN + IF EXISTS ( + SELECT 1 + FROM information_schema.tables + WHERE table_schema = current_schema() + AND table_type = 'BASE TABLE' + ) THEN + RAISE EXCEPTION 'SHiNE_DB_V2 bootstrap requires an empty PostgreSQL schema; legacy/in-place migration is disabled'; + END IF; +END +$$; + CREATE TABLE IF NOT EXISTS db_schema_version ( id INTEGER PRIMARY KEY, schema_version INTEGER NOT NULL, updated_at_ms BIGINT NOT NULL ); +-- Hard database-generation marker. Stage 2 server MUST NOT run on an older SHiNE DB. +CREATE TABLE IF NOT EXISTS shine_database_metadata ( + id INTEGER PRIMARY KEY CHECK (id = 1), + database_format TEXT NOT NULL CHECK (database_format = 'SHiNE_DB_V2'), + database_generation INTEGER NOT NULL CHECK (database_generation = 2), + created_at_ms BIGINT NOT NULL +); + +INSERT INTO shine_database_metadata(id, database_format, database_generation, created_at_ms) +VALUES (1, 'SHiNE_DB_V2', 2, CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT)) +ON CONFLICT (id) DO NOTHING; + +COMMENT ON TABLE shine_database_metadata IS 'SHiNE database generation marker. Stage 2 requires SHiNE_DB_V2 / generation 2.'; + INSERT INTO db_schema_version (id, schema_version, updated_at_ms) - VALUES (1, 24, CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT)) + VALUES (1, 29, CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT)) ON CONFLICT (id) DO UPDATE SET schema_version = EXCLUDED.schema_version, updated_at_ms = EXCLUDED.updated_at_ms; @@ -494,6 +523,7 @@ CREATE TABLE IF NOT EXISTS blocks ( block_bytes BYTEA NOT NULL, to_login TEXT, to_bch_name TEXT, + to_fork_number INTEGER CHECK (to_fork_number IS NULL OR (to_fork_number >= 0 AND to_fork_number <= 999)), to_block_number INTEGER CHECK (to_block_number IS NULL OR to_block_number >= 0), to_block_hash BYTEA, block_hash BYTEA NOT NULL, @@ -535,18 +565,26 @@ INSERT INTO arweave_block_sync_state(id, last_block_height, updated_at_ms) VALUES (1, 0, 0) ON CONFLICT (id) DO NOTHING; CREATE TABLE IF NOT EXISTS arweave_block_import_queue ( - data_item_id BYTEA PRIMARY KEY, - root_tx_id TEXT NOT NULL, - block_height BIGINT NOT NULL, - raw_data_item BYTEA NOT NULL, - status TEXT NOT NULL, - last_error TEXT NOT NULL DEFAULT '', - first_seen_at_ms BIGINT NOT NULL, - updated_at_ms BIGINT NOT NULL + data_item_id BYTEA PRIMARY KEY, + root_tx_id TEXT NOT NULL, + block_height BIGINT NOT NULL, + raw_data_item BYTEA NOT NULL, + status TEXT NOT NULL, + last_error TEXT NOT NULL DEFAULT '', + first_seen_at_ms BIGINT NOT NULL, + updated_at_ms BIGINT NOT NULL, + parsed_login TEXT, + parsed_fork_number INTEGER CHECK (parsed_fork_number IS NULL OR parsed_fork_number BETWEEN 1 AND 999), + parsed_block_number INTEGER CHECK (parsed_block_number IS NULL OR parsed_block_number >= 0), + parsed_block_hash BYTEA, + metadata_validated BOOLEAN NOT NULL DEFAULT FALSE ); CREATE INDEX IF NOT EXISTS idx_arweave_block_import_queue_pending ON arweave_block_import_queue(block_height,first_seen_at_ms) WHERE status='PENDING'; +CREATE INDEX IF NOT EXISTS idx_arweave_block_import_queue_canonical_order + ON arweave_block_import_queue(parsed_login,parsed_block_number,parsed_fork_number,first_seen_at_ms) + WHERE status='PENDING' AND metadata_validated=TRUE; CREATE TABLE IF NOT EXISTS connections_state ( login TEXT NOT NULL REFERENCES solana_user_pda_current(normalized_login), @@ -627,7 +665,10 @@ CREATE TABLE IF NOT EXISTS channel_names_state ( ava_ar TEXT NOT NULL DEFAULT '', ava_sha256 TEXT NOT NULL DEFAULT '', ava_size BIGINT NOT NULL DEFAULT 0, - meta_updated_at_ms BIGINT NOT NULL DEFAULT 0 + meta_updated_at_ms BIGINT NOT NULL DEFAULT 0, + is_deleted BOOLEAN NOT NULL DEFAULT FALSE, + deleted_at_ms BIGINT NOT NULL DEFAULT 0, + deleted_block_number INTEGER ); CREATE UNIQUE INDEX IF NOT EXISTS uq_channel_names_state_owner_type_slug @@ -1080,6 +1121,7 @@ LANGUAGE plpgsql AS $$ DECLARE prev_block RECORD; + tail_block_number INTEGER; BEGIN IF NEW.line_code IS NULL AND NEW.prev_line_number IS NULL @@ -1119,26 +1161,35 @@ BEGIN RAISE EXCEPTION 'LINE_ERR_LINE_CODE_MISMATCH'; END IF; - IF NEW.prev_line_number = NEW.line_code THEN + SELECT block_number + INTO tail_block_number + FROM blocks + WHERE bch_name = NEW.bch_name + AND msg_type = NEW.msg_type + AND line_code = NEW.line_code + ORDER BY block_number DESC + LIMIT 1; + + IF tail_block_number IS NULL THEN + IF NEW.prev_line_number <> NEW.line_code THEN + RAISE EXCEPTION 'LINE_ERR_NOT_CURRENT_TAIL'; + END IF; IF NEW.this_line_number <> (CASE WHEN NEW.msg_type = 1 THEN 0 ELSE 1 END) THEN RAISE EXCEPTION 'LINE_ERR_FIRST_STEP_BAD_THIS'; END IF; RETURN NEW; END IF; + IF NEW.prev_line_number <> tail_block_number THEN + RAISE EXCEPTION 'LINE_ERR_NOT_CURRENT_TAIL'; + END IF; + IF prev_block.this_line_number IS NULL THEN RAISE EXCEPTION 'LINE_ERR_THIS_LINE_BAD_STEP'; END IF; - IF NEW.msg_type = 1 THEN - IF NEW.this_line_number <> prev_block.this_line_number - AND NEW.this_line_number <> prev_block.this_line_number + 1 THEN - RAISE EXCEPTION 'LINE_ERR_THIS_LINE_BAD_STEP'; - END IF; - ELSE - IF NEW.this_line_number <> prev_block.this_line_number + 1 THEN - RAISE EXCEPTION 'LINE_ERR_THIS_LINE_BAD_STEP'; - END IF; + IF NEW.this_line_number <> prev_block.this_line_number + 1 THEN + RAISE EXCEPTION 'LINE_ERR_THIS_LINE_BAD_STEP'; END IF; RETURN NEW; @@ -1826,11 +1877,11 @@ BEGIN primary_confirmations_received_count, primary_confirmations_given_count, shine_confirmations_received_count, shine_confirmations_given_count, updated_at_ms) SELECT p_login, - (SELECT COUNT(*)::INT FROM channel_names_state cn WHERE LOWER(cn.owner_login)=LOWER(p_login) AND cn.channel_type_code=1), + (SELECT COUNT(*)::INT FROM channel_names_state cn WHERE LOWER(cn.owner_login)=LOWER(p_login) AND cn.channel_type_code=1 AND NOT cn.is_deleted), 0, (SELECT COUNT(*)::INT FROM connections_state cs JOIN channel_names_state cn ON cn.owner_bch_name=cs.to_bch_name 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(p_login) AND cs.rel_type=30 AND cn.channel_type_code=1), + WHERE LOWER(cs.login)=LOWER(p_login) AND cs.rel_type=30 AND cn.channel_type_code=1 AND NOT cn.is_deleted), (SELECT COUNT(DISTINCT LOWER(cs.to_login))::INT FROM connections_state cs WHERE LOWER(cs.login)=LOWER(p_login) AND cs.rel_type=10), (SELECT COUNT(DISTINCT LOWER(cs.to_login))::INT FROM connections_state cs WHERE LOWER(cs.login)=LOWER(p_login) AND cs.rel_type=14 @@ -2081,8 +2132,532 @@ CREATE INDEX IF NOT EXISTS idx_solana_user_pda_current_archive_pending ON solana_user_pda_current(is_server, archive_imported) WHERE archive_head_tx_id <> ''; -INSERT INTO db_schema_version(id,schema_version,updated_at_ms) -VALUES(1,24,CAST(EXTRACT(EPOCH FROM clock_timestamp())*1000 AS BIGINT)) -ON CONFLICT(id) DO UPDATE SET schema_version=EXCLUDED.schema_version, updated_at_ms=EXCLUDED.updated_at_ms; +-- Server-local key rotation state machine (schema v26). +-- Эти поля не являются частью Solana PDA и не перезаписываются Solana sync upsert-ом. +ALTER TABLE solana_user_pda_current + ADD COLUMN IF NOT EXISTS rotation_status TEXT NOT NULL DEFAULT 'NONE'; +ALTER TABLE solana_user_pda_current + ADD COLUMN IF NOT EXISTS rotation_session_id BIGINT; + +ALTER TABLE solana_user_pda_current + DROP CONSTRAINT IF EXISTS chk_solana_user_pda_current_rotation_status; +ALTER TABLE solana_user_pda_current + ADD CONSTRAINT chk_solana_user_pda_current_rotation_status CHECK ( + rotation_status IN ( + 'NONE','COPYING_CHAIN','CHAIN_READY','ROTATING_PDA','PDA_ROTATED', + 'REBUILDING_SERVER','WALLET_MIGRATION','MESSAGE_MIGRATION','FINALIZING' + ) + ); + +CREATE INDEX IF NOT EXISTS idx_solana_user_pda_current_rotation_active + ON solana_user_pda_current(rotation_status) + WHERE rotation_status <> 'NONE'; + +CREATE TABLE IF NOT EXISTS key_rotation_sessions ( + id BIGSERIAL PRIMARY KEY, + login TEXT NOT NULL REFERENCES solana_user_pda_current(login) ON DELETE CASCADE, + status TEXT NOT NULL CHECK ( + status IN ( + 'COPYING_CHAIN','CHAIN_READY','ROTATING_PDA','PDA_ROTATED', + 'REBUILDING_SERVER','WALLET_MIGRATION','MESSAGE_MIGRATION','FINALIZING', + 'COMPLETE','ABORTED' + ) + ), + source_blockchain_name TEXT NOT NULL, + candidate_blockchain_name TEXT NOT NULL, + old_root_key TEXT NOT NULL, + old_blockchain_key TEXT NOT NULL, + old_client_key TEXT NOT NULL, + new_root_key TEXT NOT NULL, + new_blockchain_key TEXT NOT NULL, + new_client_key TEXT NOT NULL, + fork_from_block INTEGER NOT NULL CHECK (fork_from_block >= 0), + fork_from_hash BYTEA NOT NULL CHECK (octet_length(fork_from_hash) = 32), + source_tip_block INTEGER NOT NULL CHECK (source_tip_block >= 0), + source_tip_hash BYTEA NOT NULL CHECK (octet_length(source_tip_hash) = 32), + reason_code SMALLINT NOT NULL CHECK (reason_code BETWEEN 1 AND 4), + comment TEXT NOT NULL DEFAULT '' CHECK (octet_length(convert_to(comment, 'UTF8')) <= 1024), + progress_current INTEGER NOT NULL DEFAULT 0 CHECK (progress_current >= 0), + progress_total INTEGER NOT NULL DEFAULT 0 CHECK (progress_total >= 0), + pda_rotation_signature TEXT, + wallet_migration_status TEXT NOT NULL DEFAULT 'PENDING' CHECK ( + wallet_migration_status IN ('PENDING','COMPLETE','SKIPPED','NOT_IMPLEMENTED') + ), + message_migration_status TEXT NOT NULL DEFAULT 'PENDING' CHECK ( + message_migration_status IN ('PENDING','COMPLETE','SKIPPED','NOT_IMPLEMENTED') + ), + last_error TEXT, + last_error_at_ms BIGINT, + retry_count INTEGER NOT NULL DEFAULT 0 CHECK (retry_count >= 0), + created_at_ms BIGINT NOT NULL, + updated_at_ms BIGINT NOT NULL, + completed_at_ms BIGINT, + aborted_at_ms BIGINT, + CHECK (progress_current <= progress_total), + CHECK (fork_from_block <= source_tip_block) +); + +CREATE UNIQUE INDEX IF NOT EXISTS uq_key_rotation_sessions_active_login + ON key_rotation_sessions(login) + WHERE status NOT IN ('COMPLETE','ABORTED'); +CREATE INDEX IF NOT EXISTS idx_key_rotation_sessions_login_created + ON key_rotation_sessions(login, created_at_ms DESC); +CREATE INDEX IF NOT EXISTS idx_key_rotation_sessions_status + ON key_rotation_sessions(status); + +CREATE TABLE IF NOT EXISTS key_rotation_candidate_blocks ( + id BIGSERIAL PRIMARY KEY, + rotation_session_id BIGINT NOT NULL REFERENCES key_rotation_sessions(id) ON DELETE CASCADE, + login TEXT NOT NULL, + candidate_blockchain_name TEXT NOT NULL, + block_number INTEGER NOT NULL CHECK (block_number >= 0), + block_hash BYTEA NOT NULL CHECK (octet_length(block_hash) = 32), + data_item_id BYTEA NOT NULL CHECK (octet_length(data_item_id) = 32), + block_bytes BYTEA NOT NULL, + arweave_publish_pending BOOLEAN NOT NULL DEFAULT TRUE, + arweave_published_at_ms BIGINT, + created_at_ms BIGINT NOT NULL, + UNIQUE (rotation_session_id, block_number), + UNIQUE (rotation_session_id, data_item_id) +); + +CREATE INDEX IF NOT EXISTS idx_key_rotation_candidate_blocks_pending + ON key_rotation_candidate_blocks(id) + WHERE arweave_publish_pending = TRUE; +CREATE INDEX IF NOT EXISTS idx_key_rotation_candidate_blocks_session + ON key_rotation_candidate_blocks(rotation_session_id, block_number); + +ALTER TABLE solana_user_pda_current + DROP CONSTRAINT IF EXISTS fk_solana_user_pda_current_rotation_session; +ALTER TABLE solana_user_pda_current + ADD CONSTRAINT fk_solana_user_pda_current_rotation_session + FOREIGN KEY (rotation_session_id) + REFERENCES key_rotation_sessions(id) + ON DELETE SET NULL; + +-- Stage 2 final schema: numeric physical forks and logical cross-fork targets. +-- Stage 2: physical fork identity = (login,fork_number); logical target = (login,block_number,hash). +ALTER TABLE solana_user_pda_current + ADD CONSTRAINT chk_solana_current_blockchain_name_fork + CHECK (blockchain_name ~ '-[0-9]{3}$' + AND substring(blockchain_name from '([0-9]{3})$')::INTEGER BETWEEN 1 AND 999); + +ALTER TABLE blockchain_state ADD COLUMN IF NOT EXISTS fork_number INTEGER; +UPDATE blockchain_state +SET fork_number = NULLIF(regexp_replace(blockchain_name, '^.*-([0-9]{3})$', '\1'), blockchain_name)::INTEGER +WHERE fork_number IS NULL AND blockchain_name ~ '-[0-9]{3}$'; +ALTER TABLE blockchain_state ALTER COLUMN fork_number SET NOT NULL; +ALTER TABLE blockchain_state ADD CONSTRAINT chk_blockchain_state_fork CHECK (fork_number BETWEEN 1 AND 999); +CREATE UNIQUE INDEX IF NOT EXISTS uq_blockchain_state_login_fork ON blockchain_state(login,fork_number); + +ALTER TABLE blocks ADD COLUMN IF NOT EXISTS fork_number INTEGER; +UPDATE blocks b SET fork_number=s.fork_number FROM blockchain_state s WHERE b.bch_name=s.blockchain_name AND b.fork_number IS NULL; +ALTER TABLE blocks ALTER COLUMN fork_number SET NOT NULL; +ALTER TABLE blocks ADD CONSTRAINT chk_blocks_fork CHECK (fork_number BETWEEN 1 AND 999); + +-- Triggers stay attached when tables are renamed; replace their functions below before new writes. +ALTER TABLE blocks DROP CONSTRAINT IF EXISTS blocks_bch_name_fkey; +ALTER TABLE blocks RENAME TO blocks_store; +ALTER TABLE blockchain_state RENAME TO blockchain_state_store; +ALTER TABLE blocks_store DROP COLUMN bch_name; +ALTER TABLE blocks_store DROP COLUMN to_bch_name; +ALTER TABLE blockchain_state_store DROP CONSTRAINT IF EXISTS blockchain_state_pkey; +ALTER TABLE blockchain_state_store DROP COLUMN blockchain_name; +ALTER TABLE blockchain_state_store ADD PRIMARY KEY(login,fork_number); +ALTER TABLE blocks_store ADD CONSTRAINT fk_blocks_physical_fork FOREIGN KEY(login,fork_number) + REFERENCES blockchain_state_store(login,fork_number); +DROP INDEX IF EXISTS idx_blocks_by_chain_number; +DROP INDEX IF EXISTS idx_blocks_to_target; +DROP INDEX IF EXISTS idx_blocks_by_line; +CREATE UNIQUE INDEX uq_blocks_physical_number ON blocks_store(login,fork_number,block_number); +CREATE INDEX idx_blocks_to_logical_target ON blocks_store(to_login,to_block_number,to_block_hash); +CREATE INDEX idx_blocks_by_line_v29 ON blocks_store(login,fork_number,line_code,this_line_number); + +-- Compatibility views: names are derived, never stored. +CREATE VIEW blockchain_state AS +SELECT login || '-' || lpad(fork_number::text,3,'0') AS blockchain_name, s.* FROM blockchain_state_store s; +CREATE VIEW blocks AS +SELECT b.login, + b.login || '-' || lpad(b.fork_number::text,3,'0') AS bch_name, + b.fork_number,b.block_number,b.msg_type,b.msg_sub_type,b.block_bytes, + b.to_login, + CASE WHEN b.to_login IS NOT NULL AND b.to_fork_number BETWEEN 1 AND 999 + THEN b.to_login || '-' || lpad(b.to_fork_number::text,3,'0') END AS to_bch_name, + b.to_fork_number,b.to_block_number,b.to_block_hash,b.block_hash,b.block_signature,b.data_item_id, + b.arweave_publish_pending,b.arweave_published_at_ms,b.arweave_root_tx_id,b.edited_by_block_number, + b.line_code,b.prev_line_number,b.prev_line_hash,b.this_line_number +FROM blocks_store b; + +-- Channel read state keeps the signed/display owner_bch_name, but identity no longer depends on a fork. +ALTER TABLE channel_read_state DROP CONSTRAINT IF EXISTS channel_read_state_pkey; +ALTER TABLE channel_read_state ADD PRIMARY KEY(viewer_login,owner_login,channel_name); + +-- Derived social state is cheap to rebuild and intentionally loses physical fork names. +DROP TABLE IF EXISTS reactions_state CASCADE; +DROP TABLE IF EXISTS message_stats CASCADE; +DROP TABLE IF EXISTS connections_state CASCADE; +CREATE TABLE connections_state( + login TEXT NOT NULL, rel_type INTEGER NOT NULL, to_login TEXT NOT NULL, + to_block_number INTEGER NOT NULL, to_block_hash BYTEA NOT NULL, + UNIQUE(login,rel_type,to_login,to_block_number,to_block_hash) +); +CREATE INDEX idx_connections_state_login_v29 ON connections_state(login); +CREATE INDEX idx_connections_state_to_login_v29 ON connections_state(to_login); +CREATE INDEX idx_connections_state_target_v29 ON connections_state(to_login,to_block_number,to_block_hash); + +CREATE TABLE message_stats( + to_login TEXT NOT NULL, to_block_number INTEGER NOT NULL, to_block_hash BYTEA NOT NULL, + likes_count INTEGER NOT NULL DEFAULT 0, + primary_likes_count INTEGER NOT NULL DEFAULT 0, + shining_likes_count INTEGER NOT NULL DEFAULT 0, + replies_count INTEGER NOT NULL DEFAULT 0, + UNIQUE(to_login,to_block_number,to_block_hash) +); +CREATE INDEX idx_message_stats_target_v29 ON message_stats(to_login,to_block_number,to_block_hash); + +CREATE TABLE reactions_state( + from_login TEXT NOT NULL, reaction_type INTEGER NOT NULL, + to_login TEXT NOT NULL, to_block_number INTEGER NOT NULL, to_block_hash BYTEA NOT NULL, + last_sub_type INTEGER NOT NULL, + UNIQUE(from_login,reaction_type,to_login,to_block_number,to_block_hash) +); +CREATE INDEX idx_reactions_state_target_v29 ON reactions_state(to_login,to_block_number,to_block_hash); +CREATE INDEX idx_reactions_state_actor_v29 ON reactions_state(from_login,reaction_type); + +DROP TABLE IF EXISTS message_views_state; +CREATE TABLE message_views_state( + viewer_login TEXT NOT NULL, to_login TEXT NOT NULL, to_block_number INTEGER NOT NULL, + to_block_hash BYTEA NOT NULL, first_seen_at_ms BIGINT NOT NULL, + PRIMARY KEY(viewer_login,to_login,to_block_number,to_block_hash) +); +CREATE INDEX idx_message_views_target_v29 ON message_views_state(to_login,to_block_number,to_block_hash); + +CREATE OR REPLACE FUNCTION shine_refresh_user_stats(p_login TEXT) RETURNS VOID LANGUAGE plpgsql AS $$ +DECLARE v_now BIGINT:=CAST(EXTRACT(EPOCH FROM clock_timestamp())*1000 AS BIGINT); +BEGIN + IF p_login IS NULL OR btrim(p_login)='' THEN RETURN; END IF; + INSERT INTO user_stats_state(login,owned_public_channels_count,following_users_count,following_channels_count,close_friends_count,friends_count, + primary_confirmations_received_count,primary_confirmations_given_count,shine_confirmations_received_count,shine_confirmations_given_count,updated_at_ms) + SELECT p_login, + (SELECT COUNT(*)::INT FROM channel_names_state cn WHERE LOWER(cn.owner_login)=LOWER(p_login) AND cn.channel_type_code=1 AND NOT cn.is_deleted), + (SELECT COUNT(DISTINCT LOWER(cs.to_login))::INT FROM connections_state cs WHERE LOWER(cs.login)=LOWER(p_login) AND cs.rel_type=30 AND cs.to_block_number=0), + (SELECT COUNT(*)::INT 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(p_login) AND cs.rel_type=30 AND cn.channel_type_code=1 AND NOT cn.is_deleted), + (SELECT COUNT(DISTINCT LOWER(cs.to_login))::INT FROM connections_state cs WHERE LOWER(cs.login)=LOWER(p_login) AND cs.rel_type=10), + (SELECT COUNT(DISTINCT LOWER(cs.to_login))::INT FROM connections_state cs WHERE LOWER(cs.login)=LOWER(p_login) AND cs.rel_type=14 AND NOT EXISTS(SELECT 1 FROM connections_state cf WHERE LOWER(cf.login)=LOWER(p_login) AND LOWER(cf.to_login)=LOWER(cs.to_login) AND cf.rel_type=10)), + (SELECT COUNT(DISTINCT LOWER(cs.login))::INT FROM connections_state cs WHERE LOWER(cs.to_login)=LOWER(p_login) AND cs.rel_type=80 AND shine_is_primary(cs.login) AND shine_target_accepts_primary_confirmation(p_login)), + (SELECT COUNT(DISTINCT LOWER(cs.to_login))::INT FROM connections_state cs WHERE LOWER(cs.login)=LOWER(p_login) AND cs.rel_type=80 AND shine_is_primary(p_login) AND shine_target_accepts_primary_confirmation(cs.to_login)), + (SELECT COUNT(DISTINCT LOWER(cs.login))::INT FROM connections_state cs WHERE LOWER(cs.to_login)=LOWER(p_login) AND cs.rel_type=70 AND shine_is_primary(cs.login) AND shine_is_shining(cs.login) AND shine_target_accepts_shine_confirmation(p_login)), + (SELECT COUNT(DISTINCT LOWER(cs.to_login))::INT FROM connections_state cs WHERE LOWER(cs.login)=LOWER(p_login) AND cs.rel_type=70 AND shine_is_primary(p_login) AND shine_is_shining(p_login) AND shine_target_accepts_shine_confirmation(cs.to_login)),v_now + ON CONFLICT(login) DO UPDATE SET owned_public_channels_count=EXCLUDED.owned_public_channels_count,following_users_count=EXCLUDED.following_users_count,following_channels_count=EXCLUDED.following_channels_count,close_friends_count=EXCLUDED.close_friends_count,friends_count=EXCLUDED.friends_count,primary_confirmations_received_count=EXCLUDED.primary_confirmations_received_count,primary_confirmations_given_count=EXCLUDED.primary_confirmations_given_count,shine_confirmations_received_count=EXCLUDED.shine_confirmations_received_count,shine_confirmations_given_count=EXCLUDED.shine_confirmations_given_count,updated_at_ms=EXCLUDED.updated_at_ms; +END $$; + +CREATE OR REPLACE FUNCTION shine_refresh_message_qualified_likes_for_actor(p_login TEXT) RETURNS VOID LANGUAGE plpgsql AS $$ +DECLARE r RECORD; +BEGIN + FOR r IN SELECT DISTINCT to_login,to_block_number,to_block_hash FROM reactions_state WHERE LOWER(from_login)=LOWER(p_login) AND reaction_type=1 AND last_sub_type=1 LOOP + UPDATE message_stats ms SET + primary_likes_count=(SELECT COUNT(*)::INT FROM reactions_state x WHERE x.reaction_type=1 AND x.last_sub_type=1 AND x.to_login=r.to_login AND x.to_block_number=r.to_block_number AND x.to_block_hash=r.to_block_hash AND shine_is_primary(x.from_login)), + shining_likes_count=(SELECT COUNT(*)::INT FROM reactions_state x WHERE x.reaction_type=1 AND x.last_sub_type=1 AND x.to_login=r.to_login AND x.to_block_number=r.to_block_number AND x.to_block_hash=r.to_block_hash AND shine_is_primary(x.from_login) AND shine_is_shining(x.from_login)) + WHERE ms.to_login=r.to_login AND ms.to_block_number=r.to_block_number AND ms.to_block_hash=r.to_block_hash; + END LOOP; +END $$; + +CREATE OR REPLACE FUNCTION shine_refresh_channel_follow_stats(p_bch_name TEXT,p_block_number INTEGER,p_block_hash BYTEA) RETURNS VOID LANGUAGE plpgsql AS $$ +DECLARE v_owner TEXT; v_type INTEGER; v_count INTEGER; v_now BIGINT:=CAST(EXTRACT(EPOCH FROM clock_timestamp())*1000 AS BIGINT); +BEGIN + SELECT owner_login,channel_type_code INTO v_owner,v_type FROM channel_names_state WHERE owner_bch_name=p_bch_name AND channel_root_block_number=p_block_number AND channel_root_block_hash=p_block_hash LIMIT 1; + IF v_owner IS NULL THEN RETURN; END IF; + SELECT COUNT(DISTINCT cs.login)::INTEGER INTO v_count FROM connections_state cs WHERE cs.rel_type=30 AND LOWER(cs.to_login)=LOWER(v_owner) AND cs.to_block_number=p_block_number AND cs.to_block_hash=p_block_hash; + INSERT INTO channel_stats_state(owner_bch_name,channel_root_block_number,channel_root_block_hash,owner_login,channel_type_code,subscribers_count,updated_at_ms) + VALUES(p_bch_name,p_block_number,p_block_hash,v_owner,v_type,COALESCE(v_count,0),v_now) + ON CONFLICT(owner_bch_name,channel_root_block_number,channel_root_block_hash) DO UPDATE SET subscribers_count=EXCLUDED.subscribers_count,owner_login=EXCLUDED.owner_login,channel_type_code=EXCLUDED.channel_type_code,updated_at_ms=EXCLUDED.updated_at_ms; +END $$; + +-- Channel-name projection must also use logical connection targets; the physical owner name is display/state only. +CREATE OR REPLACE FUNCTION shine_channel_names_state_stats_ai() +RETURNS TRIGGER +LANGUAGE plpgsql +AS $$ +DECLARE + now_ms BIGINT; + public_subscribers_count INTEGER; + r RECORD; +BEGIN + now_ms := CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT); + + IF NEW.owner_login IS NULL OR btrim(NEW.owner_login) = '' THEN + RETURN NEW; + END IF; + + IF NEW.channel_type_code = 1 THEN + IF EXISTS ( + SELECT 1 FROM solana_user_pda_current su WHERE LOWER(su.login)=LOWER(NEW.owner_login) + ) THEN + INSERT INTO user_stats_state ( + login, owned_public_channels_count, following_users_count, following_channels_count, + close_friends_count, updated_at_ms + ) VALUES (NEW.owner_login, 1, 0, 0, 0, now_ms) + ON CONFLICT (login) DO UPDATE SET + owned_public_channels_count = user_stats_state.owned_public_channels_count + 1, + updated_at_ms = EXCLUDED.updated_at_ms; + END IF; + + SELECT COUNT(*)::INTEGER + INTO public_subscribers_count + FROM connections_state cs + WHERE cs.rel_type = 30 + AND LOWER(cs.to_login)=LOWER(NEW.owner_login) + AND cs.to_block_number = NEW.channel_root_block_number + AND cs.to_block_hash = NEW.channel_root_block_hash; + + INSERT INTO channel_stats_state ( + owner_bch_name, channel_root_block_number, channel_root_block_hash, + owner_login, channel_type_code, subscribers_count, updated_at_ms + ) VALUES ( + NEW.owner_bch_name, NEW.channel_root_block_number, NEW.channel_root_block_hash, + NEW.owner_login, NEW.channel_type_code, COALESCE(public_subscribers_count, 0), now_ms + ) + ON CONFLICT (owner_bch_name, channel_root_block_number, channel_root_block_hash) DO UPDATE SET + owner_login = EXCLUDED.owner_login, + channel_type_code = EXCLUDED.channel_type_code, + subscribers_count = EXCLUDED.subscribers_count, + updated_at_ms = EXCLUDED.updated_at_ms; + + -- A channel may disappear during cleanup and reappear during replay. Recompute followers from logical state. + FOR r IN + SELECT DISTINCT cs.login + FROM connections_state cs + WHERE cs.rel_type = 30 + AND LOWER(cs.to_login)=LOWER(NEW.owner_login) + AND cs.to_block_number = NEW.channel_root_block_number + AND cs.to_block_hash = NEW.channel_root_block_hash + LOOP + PERFORM shine_refresh_user_stats(r.login); + END LOOP; + ELSE + WITH pending AS ( + SELECT cs.login, COUNT(*)::INTEGER AS cnt + FROM connections_state cs + WHERE cs.rel_type = 30 + AND LOWER(cs.to_login)=LOWER(NEW.owner_login) + AND cs.to_block_number = NEW.channel_root_block_number + AND cs.to_block_hash = NEW.channel_root_block_hash + GROUP BY cs.login + ) + UPDATE user_stats_state us + SET following_channels_count = GREATEST(0, us.following_channels_count - pending.cnt), + updated_at_ms = now_ms + FROM pending + WHERE LOWER(us.login)=LOWER(pending.login); + END IF; + + RETURN NEW; +END; +$$; + +-- Physical chain integrity uses numeric fork identity. +CREATE OR REPLACE FUNCTION shine_blocks_line_integrity_bi() RETURNS TRIGGER LANGUAGE plpgsql AS $$ +DECLARE prev_block RECORD; tail_block_number INTEGER; +BEGIN + IF NEW.line_code IS NULL AND NEW.prev_line_number IS NULL AND NEW.prev_line_hash IS NULL AND NEW.this_line_number IS NULL THEN RETURN NEW; END IF; + IF NEW.msg_type NOT IN (0,1,3,4) THEN RAISE EXCEPTION 'LINE_ERR_UNSUPPORTED_TYPE_WITH_LINE'; END IF; + IF NEW.line_code IS NULL OR NEW.prev_line_number IS NULL OR NEW.prev_line_hash IS NULL OR NEW.this_line_number IS NULL THEN RAISE EXCEPTION 'LINE_ERR_PARTIAL_FIELDS'; END IF; + SELECT * INTO prev_block FROM blocks_store WHERE login=NEW.login AND fork_number=NEW.fork_number AND block_number=NEW.prev_line_number LIMIT 1; + IF NOT FOUND THEN RAISE EXCEPTION 'LINE_ERR_NO_PREV'; END IF; + IF prev_block.block_hash IS DISTINCT FROM NEW.prev_line_hash THEN RAISE EXCEPTION 'LINE_ERR_PREV_HASH_MISMATCH'; END IF; + IF NEW.prev_line_number<>NEW.line_code AND prev_block.line_code IS DISTINCT FROM NEW.line_code THEN RAISE EXCEPTION 'LINE_ERR_LINE_CODE_MISMATCH'; END IF; + SELECT block_number INTO tail_block_number FROM blocks_store + WHERE login=NEW.login AND fork_number=NEW.fork_number AND msg_type=NEW.msg_type AND line_code=NEW.line_code + ORDER BY block_number DESC LIMIT 1; + IF tail_block_number IS NULL THEN + IF NEW.prev_line_number<>NEW.line_code THEN RAISE EXCEPTION 'LINE_ERR_NOT_CURRENT_TAIL'; END IF; + IF NEW.this_line_number<>(CASE WHEN NEW.msg_type=1 THEN 0 ELSE 1 END) THEN RAISE EXCEPTION 'LINE_ERR_FIRST_STEP_BAD_THIS'; END IF; + RETURN NEW; + END IF; + IF NEW.prev_line_number<>tail_block_number THEN RAISE EXCEPTION 'LINE_ERR_NOT_CURRENT_TAIL'; END IF; + IF prev_block.this_line_number IS NULL THEN RAISE EXCEPTION 'LINE_ERR_THIS_LINE_BAD_STEP'; END IF; + IF NEW.this_line_number<>prev_block.this_line_number+1 THEN RAISE EXCEPTION 'LINE_ERR_THIS_LINE_BAD_STEP'; END IF; + RETURN NEW; +END $$; + +CREATE OR REPLACE FUNCTION shine_blocks_connection_state_ai() RETURNS TRIGGER LANGUAGE plpgsql AS $$ +DECLARE positive_rel_type INTEGER; channel_bch TEXT; +BEGIN + IF NEW.msg_type<>3 OR NEW.to_login IS NULL OR NEW.to_block_number IS NULL OR NEW.to_block_hash IS NULL THEN RETURN NEW; END IF; + IF NEW.msg_sub_type IN (10,14,20,30,40,50,52,54,60,70,74,80) THEN + DELETE FROM connections_state WHERE login=NEW.login AND rel_type=NEW.msg_sub_type AND to_login=NEW.to_login AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash; + INSERT INTO connections_state(login,rel_type,to_login,to_block_number,to_block_hash) + VALUES(NEW.login,NEW.msg_sub_type,NEW.to_login,NEW.to_block_number,NEW.to_block_hash); + ELSE + positive_rel_type := CASE NEW.msg_sub_type WHEN 11 THEN 10 WHEN 15 THEN 14 WHEN 21 THEN 20 WHEN 31 THEN 30 WHEN 41 THEN 40 WHEN 51 THEN 50 WHEN 53 THEN 52 WHEN 55 THEN 54 WHEN 61 THEN 60 WHEN 71 THEN 70 WHEN 75 THEN 74 WHEN 81 THEN 80 ELSE NULL END; + IF positive_rel_type IS NOT NULL THEN DELETE FROM connections_state WHERE login=NEW.login AND rel_type=positive_rel_type AND to_login=NEW.to_login AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash; END IF; + END IF; + PERFORM shine_refresh_user_stats(NEW.login); + PERFORM shine_refresh_user_stats(NEW.to_login); + IF NEW.msg_sub_type IN (30,31) AND NEW.to_block_number>0 THEN + SELECT owner_bch_name INTO channel_bch FROM channel_names_state WHERE LOWER(owner_login)=LOWER(NEW.to_login) AND channel_root_block_number=NEW.to_block_number AND channel_root_block_hash=NEW.to_block_hash LIMIT 1; + IF channel_bch IS NOT NULL THEN PERFORM shine_refresh_channel_follow_stats(channel_bch,NEW.to_block_number,NEW.to_block_hash); END IF; + END IF; + RETURN NEW; +END $$; + +CREATE OR REPLACE FUNCTION shine_blocks_message_stats_like_ai() RETURNS TRIGGER LANGUAGE plpgsql AS $$ +DECLARE previous_sub_type INTEGER; +BEGIN + IF NEW.msg_type<>2 OR NEW.msg_sub_type NOT IN (1,2) THEN RETURN NEW; END IF; + IF NEW.to_login IS NULL OR NEW.to_block_number IS NULL OR NEW.to_block_hash IS NULL THEN RETURN NEW; END IF; + INSERT INTO message_stats(to_login,to_block_number,to_block_hash) VALUES(NEW.to_login,NEW.to_block_number,NEW.to_block_hash) + ON CONFLICT(to_login,to_block_number,to_block_hash) DO NOTHING; + SELECT last_sub_type INTO previous_sub_type FROM reactions_state WHERE from_login=NEW.login AND reaction_type=1 AND to_login=NEW.to_login AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash LIMIT 1; + IF NEW.msg_sub_type=1 AND previous_sub_type IS DISTINCT FROM 1 THEN + UPDATE message_stats SET likes_count=likes_count+1, + primary_likes_count=primary_likes_count+CASE WHEN shine_is_primary(NEW.login) THEN 1 ELSE 0 END, + shining_likes_count=shining_likes_count+CASE WHEN shine_is_primary(NEW.login) AND shine_is_shining(NEW.login) THEN 1 ELSE 0 END + WHERE to_login=NEW.to_login AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash; + ELSIF NEW.msg_sub_type=2 AND previous_sub_type=1 THEN + UPDATE message_stats SET likes_count=GREATEST(0,likes_count-1), + primary_likes_count=GREATEST(0,primary_likes_count-CASE WHEN shine_is_primary(NEW.login) THEN 1 ELSE 0 END), + shining_likes_count=GREATEST(0,shining_likes_count-CASE WHEN shine_is_primary(NEW.login) AND shine_is_shining(NEW.login) THEN 1 ELSE 0 END) + WHERE to_login=NEW.to_login AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash; + END IF; + INSERT INTO reactions_state(from_login,reaction_type,to_login,to_block_number,to_block_hash,last_sub_type) + VALUES(NEW.login,1,NEW.to_login,NEW.to_block_number,NEW.to_block_hash,NEW.msg_sub_type) + ON CONFLICT(from_login,reaction_type,to_login,to_block_number,to_block_hash) DO UPDATE SET last_sub_type=EXCLUDED.last_sub_type; + RETURN NEW; +END $$; + +-- Existing REPLY counter semantics are preserved; only the removed physical target-name column is adapted. +CREATE OR REPLACE FUNCTION shine_blocks_message_stats_reply_ai() RETURNS TRIGGER LANGUAGE plpgsql AS $$ +BEGIN + IF NEW.msg_type<>1 OR NEW.msg_sub_type<>20 THEN RETURN NEW; END IF; + IF NEW.to_login IS NULL OR NEW.to_block_number IS NULL OR NEW.to_block_hash IS NULL THEN RETURN NEW; END IF; + INSERT INTO message_stats(to_login,to_block_number,to_block_hash,replies_count) + VALUES(NEW.to_login,NEW.to_block_number,NEW.to_block_hash,1) + ON CONFLICT(to_login,to_block_number,to_block_hash) DO UPDATE SET replies_count=message_stats.replies_count+1; + RETURN NEW; +END $$; + +-- EDIT applies to own physical fork; no edits_count aggregate is maintained. +CREATE OR REPLACE FUNCTION shine_blocks_edit_apply_ai() RETURNS TRIGGER LANGUAGE plpgsql AS $$ +BEGIN + IF NEW.msg_type<>1 OR NEW.msg_sub_type NOT IN (11,21) THEN RETURN NEW; END IF; + IF NEW.to_block_number IS NULL OR NEW.to_block_hash IS NULL THEN RETURN NEW; END IF; + UPDATE blocks_store SET edited_by_block_number=NEW.block_number + WHERE login=NEW.login AND fork_number=NEW.fork_number AND block_number=NEW.to_block_number AND block_hash=NEW.to_block_hash; + RETURN NEW; +END $$; + +-- Triggers moved with blocks_store on rename; make sure they exist there. +DROP TRIGGER IF EXISTS trg_blocks_line_integrity_bi ON blocks_store; +CREATE TRIGGER trg_blocks_line_integrity_bi BEFORE INSERT ON blocks_store FOR EACH ROW EXECUTE FUNCTION shine_blocks_line_integrity_bi(); +DROP TRIGGER IF EXISTS trg_blocks_connection_state_ai ON blocks_store; +CREATE TRIGGER trg_blocks_connection_state_ai AFTER INSERT ON blocks_store FOR EACH ROW EXECUTE FUNCTION shine_blocks_connection_state_ai(); +DROP TRIGGER IF EXISTS trg_blocks_message_stats_like_ai ON blocks_store; +CREATE TRIGGER trg_blocks_message_stats_like_ai AFTER INSERT ON blocks_store FOR EACH ROW EXECUTE FUNCTION shine_blocks_message_stats_like_ai(); +DROP TRIGGER IF EXISTS trg_blocks_message_stats_reply_ai ON blocks_store; +CREATE TRIGGER trg_blocks_message_stats_reply_ai AFTER INSERT ON blocks_store FOR EACH ROW EXECUTE FUNCTION shine_blocks_message_stats_reply_ai(); +DROP TRIGGER IF EXISTS trg_blocks_edit_apply_ai ON blocks_store; +CREATE TRIGGER trg_blocks_edit_apply_ai AFTER INSERT ON blocks_store FOR EACH ROW EXECUTE FUNCTION shine_blocks_edit_apply_ai(); + +-- Segmented fork ancestry (schema v30). + + +CREATE TABLE IF NOT EXISTS blockchain_fork_segments ( + login TEXT NOT NULL, + fork_number INTEGER NOT NULL CHECK (fork_number BETWEEN 1 AND 999), + parent_fork_number INTEGER, + fork_point_block_number INTEGER NOT NULL DEFAULT -1, + fork_point_block_hash BYTEA, + first_physical_block_number INTEGER NOT NULL DEFAULT 0, + created_at_ms BIGINT NOT NULL DEFAULT 0, + PRIMARY KEY(login,fork_number), + CHECK ((fork_number=1 AND parent_fork_number IS NULL AND fork_point_block_number=-1 AND first_physical_block_number=0) + OR (fork_number>1 AND parent_fork_number IS NOT NULL AND parent_fork_number BETWEEN 1 AND 999 + AND fork_point_block_number>=0 AND octet_length(fork_point_block_hash)=32 + AND first_physical_block_number=fork_point_block_number+1)) +); +CREATE INDEX IF NOT EXISTS idx_blockchain_fork_segments_parent ON blockchain_fork_segments(login,parent_fork_number); + +-- Existing chains predate segmented forks. Their current physical fork is self-contained; +-- register fork 1 where possible. Later segmented forks are inserted by key rotation/recovery. +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) +SELECT login,fork_number,NULL,-1,NULL,0,updated_at_ms FROM blockchain_state_store +WHERE fork_number=1 +ON CONFLICT(login,fork_number) DO NOTHING; + + + + +-- Segmented-fork canonical helpers/triggers (schema v30 final overrides). + +CREATE OR REPLACE FUNCTION shine_canonical_fork(p_login TEXT,p_active_fork INTEGER,p_block_number INTEGER) RETURNS INTEGER LANGUAGE plpgsql STABLE AS $$ +DECLARE f INTEGER:=p_active_fork; seg RECORD; guard INTEGER:=0; +BEGIN + LOOP + guard:=guard+1; IF guard>1000 THEN RAISE EXCEPTION 'fork ancestry cycle'; END IF; + SELECT * INTO seg FROM blockchain_fork_segments WHERE LOWER(login)=LOWER(p_login) AND fork_number=f; + IF NOT FOUND THEN RETURN f; END IF; + IF seg.parent_fork_number IS NULL OR p_block_number>=seg.first_physical_block_number THEN RETURN f; END IF; + f:=seg.parent_fork_number; + END LOOP; +END $$; + +CREATE OR REPLACE FUNCTION shine_blocks_line_integrity_bi() RETURNS TRIGGER LANGUAGE plpgsql AS $$ +DECLARE prev_block RECORD; tail_block RECORD; prev_fork INTEGER; +BEGIN + IF NEW.line_code IS NULL AND NEW.prev_line_number IS NULL AND NEW.prev_line_hash IS NULL AND NEW.this_line_number IS NULL THEN RETURN NEW; END IF; + IF NEW.msg_type NOT IN (0,1,3,4) THEN RAISE EXCEPTION 'LINE_ERR_UNSUPPORTED_TYPE_WITH_LINE'; END IF; + IF NEW.line_code IS NULL OR NEW.prev_line_number IS NULL OR NEW.prev_line_hash IS NULL OR NEW.this_line_number IS NULL THEN RAISE EXCEPTION 'LINE_ERR_PARTIAL_FIELDS'; END IF; + prev_fork:=shine_canonical_fork(NEW.login,NEW.fork_number,NEW.prev_line_number); + SELECT * INTO prev_block FROM blocks_store WHERE LOWER(login)=LOWER(NEW.login) AND fork_number=prev_fork AND block_number=NEW.prev_line_number LIMIT 1; + IF NOT FOUND THEN RAISE EXCEPTION 'LINE_ERR_NO_PREV'; END IF; + IF prev_block.block_hash IS DISTINCT FROM NEW.prev_line_hash THEN RAISE EXCEPTION 'LINE_ERR_PREV_HASH_MISMATCH'; END IF; + IF NEW.prev_line_number<>NEW.line_code AND prev_block.line_code IS DISTINCT FROM NEW.line_code THEN RAISE EXCEPTION 'LINE_ERR_LINE_CODE_MISMATCH'; END IF; + SELECT b.* INTO tail_block FROM blocks_store b + WHERE LOWER(b.login)=LOWER(NEW.login) AND b.block_numberNEW.line_code THEN RAISE EXCEPTION 'LINE_ERR_NOT_CURRENT_TAIL'; END IF; + IF NEW.this_line_number<>(CASE WHEN NEW.msg_type=1 THEN 0 ELSE 1 END) THEN RAISE EXCEPTION 'LINE_ERR_FIRST_STEP_BAD_THIS'; END IF; + RETURN NEW; + END IF; + IF NEW.prev_line_number<>tail_block.block_number THEN RAISE EXCEPTION 'LINE_ERR_NOT_CURRENT_TAIL'; END IF; + IF prev_block.this_line_number IS NULL THEN RAISE EXCEPTION 'LINE_ERR_THIS_LINE_BAD_STEP'; END IF; + IF NEW.this_line_number<>prev_block.this_line_number+1 THEN RAISE EXCEPTION 'LINE_ERR_THIS_LINE_BAD_STEP'; END IF; + RETURN NEW; +END $$; + +CREATE OR REPLACE FUNCTION shine_blocks_edit_apply_ai() RETURNS TRIGGER LANGUAGE plpgsql AS $$ +DECLARE target_fork INTEGER; +BEGIN + IF NEW.msg_type<>1 OR NEW.msg_sub_type NOT IN (11,21) THEN RETURN NEW; END IF; + IF NEW.to_block_number IS NULL OR NEW.to_block_hash IS NULL THEN RETURN NEW; END IF; + target_fork:=shine_canonical_fork(NEW.login,NEW.fork_number,NEW.to_block_number); + UPDATE blocks_store SET edited_by_block_number=NEW.block_number + WHERE LOWER(login)=LOWER(NEW.login) AND fork_number=target_fork AND block_number=NEW.to_block_number AND block_hash=NEW.to_block_hash; + RETURN NEW; +END $$; + +CREATE TABLE IF NOT EXISTS key_rotation_rebuild_staging ( + rotation_session_id BIGINT NOT NULL REFERENCES key_rotation_sessions(id) ON DELETE CASCADE, + logical_block_number INTEGER NOT NULL, physical_fork_number INTEGER NOT NULL, + blockchain_key TEXT NOT NULL, block_bytes BYTEA NOT NULL, block_hash BYTEA NOT NULL, + PRIMARY KEY(rotation_session_id,logical_block_number) +); +CREATE INDEX IF NOT EXISTS idx_key_rotation_rebuild_staging_session ON key_rotation_rebuild_staging(rotation_session_id,logical_block_number); + +-- Generic crash-safe staging used when this server learns a remote fork through Arweave. +CREATE TABLE IF NOT EXISTS canonical_rebuild_staging ( + login TEXT NOT NULL, + logical_block_number INTEGER NOT NULL, + physical_fork_number INTEGER NOT NULL, + block_bytes BYTEA NOT NULL, + block_hash BYTEA NOT NULL, + PRIMARY KEY(login,logical_block_number) +); +CREATE INDEX IF NOT EXISTS idx_canonical_rebuild_staging_login ON canonical_rebuild_staging(login,logical_block_number); + +INSERT INTO db_schema_version(id,schema_version,updated_at_ms) VALUES(1,31,CAST(EXTRACT(EPOCH FROM clock_timestamp())*1000 AS BIGINT)) ON CONFLICT(id) DO UPDATE SET schema_version=EXCLUDED.schema_version,updated_at_ms=EXCLUDED.updated_at_ms; COMMIT; diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/JsonHandlerRegistry.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/JsonHandlerRegistry.java index 10406a25..d399fe06 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/JsonHandlerRegistry.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/JsonHandlerRegistry.java @@ -6,6 +6,7 @@ import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler; import server.logic.ws_protocol.JSON.handlers.auth.Net_AuthChallenge_Handler; import server.logic.ws_protocol.JSON.handlers.auth.Net_ResolveLoginForAuth_Handler; import server.logic.ws_protocol.JSON.handlers.auth.Net_CloseActiveSession_Handler; +import server.logic.ws_protocol.JSON.handlers.auth.Net_CloseOtherSessions_Handler; import server.logic.ws_protocol.JSON.handlers.auth.Net_CreateAuthSession__Handler; import server.logic.ws_protocol.JSON.handlers.auth.Net_ListSessions_Handler; import server.logic.ws_protocol.JSON.handlers.auth.Net_ListEspPairingRequests_Handler; @@ -25,6 +26,7 @@ import server.logic.ws_protocol.JSON.handlers.auth.Net_UpsertEspPairingSettings_ import server.logic.ws_protocol.JSON.handlers.auth.entyties.Net_AuthChallenge_Request; import server.logic.ws_protocol.JSON.handlers.auth.entyties.Net_ResolveLoginForAuth_Request; import server.logic.ws_protocol.JSON.handlers.auth.entyties.Net_CloseActiveSession_Request; +import server.logic.ws_protocol.JSON.handlers.auth.entyties.Net_CloseOtherSessions_Request; import server.logic.ws_protocol.JSON.handlers.auth.entyties.Net_CreateAuthSession_Request; import server.logic.ws_protocol.JSON.handlers.auth.entyties.Net_ListSessions_Request; import server.logic.ws_protocol.JSON.handlers.auth.entyties.Net_ListEspPairingRequests_Request; @@ -42,8 +44,25 @@ import server.logic.ws_protocol.JSON.handlers.auth.entyties.Net_UpsertEspPairing import server.logic.ws_protocol.JSON.handlers.blockchain.Net_AddBlock_Handler; import server.logic.ws_protocol.JSON.handlers.blockchain.Net_GetBlockchainBlock_Handler; +import server.logic.ws_protocol.JSON.handlers.blockchain.Net_GetMyBlockchain_Handler; import server.logic.ws_protocol.JSON.handlers.blockchain.entyties.Net_AddBlock_Request; import server.logic.ws_protocol.JSON.handlers.blockchain.entyties.Net_GetBlockchainBlock_Request; +import server.logic.ws_protocol.JSON.handlers.blockchain.entyties.Net_GetMyBlockchain_Request; + +import server.logic.ws_protocol.JSON.handlers.keyRotation.Net_KeyRotationStart_Handler; +import server.logic.ws_protocol.JSON.handlers.keyRotation.Net_KeyRotationAddBlock_Handler; +import server.logic.ws_protocol.JSON.handlers.keyRotation.Net_KeyRotationFinishChain_Handler; +import server.logic.ws_protocol.JSON.handlers.keyRotation.Net_KeyRotationRotatePda_Handler; +import server.logic.ws_protocol.JSON.handlers.keyRotation.Net_KeyRotationStatus_Handler; +import server.logic.ws_protocol.JSON.handlers.keyRotation.Net_KeyRotationAbort_Handler; +import server.logic.ws_protocol.JSON.handlers.keyRotation.Net_KeyRotationContinue_Handler; +import server.logic.ws_protocol.JSON.handlers.keyRotation.entyties.Net_KeyRotationStart_Request; +import server.logic.ws_protocol.JSON.handlers.keyRotation.entyties.Net_KeyRotationAddBlock_Request; +import server.logic.ws_protocol.JSON.handlers.keyRotation.entyties.Net_KeyRotationFinishChain_Request; +import server.logic.ws_protocol.JSON.handlers.keyRotation.entyties.Net_KeyRotationRotatePda_Request; +import server.logic.ws_protocol.JSON.handlers.keyRotation.entyties.Net_KeyRotationStatus_Request; +import server.logic.ws_protocol.JSON.handlers.keyRotation.entyties.Net_KeyRotationAbort_Request; +import server.logic.ws_protocol.JSON.handlers.keyRotation.entyties.Net_KeyRotationContinue_Request; import server.logic.ws_protocol.JSON.handlers.tempToTest.Net_GetUser_Handler; import server.logic.ws_protocol.JSON.handlers.tempToTest.entyties.Net_GetUser_Request; @@ -109,6 +128,7 @@ import server.logic.ws_protocol.JSON.messages.Net_CallSignalToSession_Handler; import server.logic.ws_protocol.JSON.messages.Net_DeleteConversation_Handler; import server.logic.ws_protocol.JSON.messages.Net_DeleteMessage_Handler; import server.logic.ws_protocol.JSON.messages.Net_GetDirectMessages_Handler; +import server.logic.ws_protocol.JSON.messages.Net_ReencryptDirectMessage_Handler; import server.logic.ws_protocol.JSON.messages.Net_SendSignal_Handler; import server.logic.ws_protocol.JSON.messages.Net_ReceiveIncomingMessage_Handler; import server.logic.ws_protocol.JSON.messages.Net_SendMessagePair_Handler; @@ -120,6 +140,7 @@ import server.logic.ws_protocol.JSON.messages.entyties.Net_CallSignalToSession_R import server.logic.ws_protocol.JSON.messages.entyties.Net_DeleteConversation_Request; import server.logic.ws_protocol.JSON.messages.entyties.Net_DeleteMessage_Request; import server.logic.ws_protocol.JSON.messages.entyties.Net_GetDirectMessages_Request; +import server.logic.ws_protocol.JSON.messages.entyties.Net_ReencryptDirectMessage_Request; import server.logic.ws_protocol.JSON.messages.entyties.Net_SendSignal_Request; import server.logic.ws_protocol.JSON.messages.entyties.Net_ReceiveIncomingMessage_Request; import server.logic.ws_protocol.JSON.messages.entyties.Net_SendMessagePair_Request; @@ -167,6 +188,7 @@ public final class JsonHandlerRegistry { Map.entry("AuthChallenge", new Net_AuthChallenge_Handler()), Map.entry("CreateAuthSession", new Net_CreateAuthSession__Handler()), Map.entry("CloseActiveSession", new Net_CloseActiveSession_Handler()), + Map.entry("CloseOtherSessions", new Net_CloseOtherSessions_Handler()), Map.entry("ListSessions", new Net_ListSessions_Handler()), // --- login to existing session in 2 steps --- @@ -191,6 +213,16 @@ public final class JsonHandlerRegistry { // --- blockchain --- Map.entry("AddBlock", new Net_AddBlock_Handler()), Map.entry("GetBlockchainBlock", new Net_GetBlockchainBlock_Handler()), + Map.entry("GetMyBlockchain", new Net_GetMyBlockchain_Handler()), + + // --- key rotation --- + Map.entry("KeyRotationStart", new Net_KeyRotationStart_Handler()), + Map.entry("KeyRotationStatus", new Net_KeyRotationStatus_Handler()), + Map.entry("KeyRotationAddBlock", new Net_KeyRotationAddBlock_Handler()), + Map.entry("KeyRotationFinishChain", new Net_KeyRotationFinishChain_Handler()), + Map.entry("KeyRotationRotatePda", new Net_KeyRotationRotatePda_Handler()), + Map.entry("KeyRotationContinue", new Net_KeyRotationContinue_Handler()), + Map.entry("KeyRotationAbort", new Net_KeyRotationAbort_Handler()), // --- userParams --- Map.entry("UpsertUserParam", new Net_UpsertUserParam_Handler()), @@ -230,6 +262,7 @@ public final class JsonHandlerRegistry { Map.entry("DeleteMessage", new Net_DeleteMessage_Handler()), Map.entry("DeleteConversation", new Net_DeleteConversation_Handler()), Map.entry("GetDirectMessages", new Net_GetDirectMessages_Handler()), + Map.entry("ReencryptDirectMessage", new Net_ReencryptDirectMessage_Handler()), Map.entry("AckSessionDelivery", new Net_AckSessionDelivery_Handler()), Map.entry("CallInviteBroadcast", new Net_CallInviteBroadcast_Handler()), Map.entry("CallSignalToSession", new Net_CallSignalToSession_Handler()), @@ -259,6 +292,7 @@ public final class JsonHandlerRegistry { Map.entry("AuthChallenge", Net_AuthChallenge_Request.class), Map.entry("CreateAuthSession", Net_CreateAuthSession_Request.class), Map.entry("CloseActiveSession", Net_CloseActiveSession_Request.class), + Map.entry("CloseOtherSessions", Net_CloseOtherSessions_Request.class), Map.entry("ListSessions", Net_ListSessions_Request.class), // --- NEW v2 --- @@ -283,6 +317,16 @@ public final class JsonHandlerRegistry { // --- blockchain --- Map.entry("AddBlock", Net_AddBlock_Request.class), Map.entry("GetBlockchainBlock", Net_GetBlockchainBlock_Request.class), + Map.entry("GetMyBlockchain", Net_GetMyBlockchain_Request.class), + + // --- key rotation --- + Map.entry("KeyRotationStart", Net_KeyRotationStart_Request.class), + Map.entry("KeyRotationStatus", Net_KeyRotationStatus_Request.class), + Map.entry("KeyRotationAddBlock", Net_KeyRotationAddBlock_Request.class), + Map.entry("KeyRotationFinishChain", Net_KeyRotationFinishChain_Request.class), + Map.entry("KeyRotationRotatePda", Net_KeyRotationRotatePda_Request.class), + Map.entry("KeyRotationContinue", Net_KeyRotationContinue_Request.class), + Map.entry("KeyRotationAbort", Net_KeyRotationAbort_Request.class), // --- userParams --- Map.entry("UpsertUserParam", Net_UpsertUserParam_Request.class), @@ -322,6 +366,7 @@ public final class JsonHandlerRegistry { Map.entry("DeleteMessage", Net_DeleteMessage_Request.class), Map.entry("DeleteConversation", Net_DeleteConversation_Request.class), Map.entry("GetDirectMessages", Net_GetDirectMessages_Request.class), + Map.entry("ReencryptDirectMessage", Net_ReencryptDirectMessage_Request.class), Map.entry("AckSessionDelivery", Net_AckSessionDelivery_Request.class), Map.entry("CallInviteBroadcast", Net_CallInviteBroadcast_Request.class), Map.entry("CallSignalToSession", Net_CallSignalToSession_Request.class), diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/Net_CloseActiveSession_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/Net_CloseActiveSession_Handler.java index cd29954f..23dade08 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/Net_CloseActiveSession_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/Net_CloseActiveSession_Handler.java @@ -1,10 +1,7 @@ package server.logic.ws_protocol.JSON.handlers.auth; -import com.fasterxml.jackson.databind.ObjectMapper; -import com.fasterxml.jackson.databind.node.ObjectNode; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import server.logic.ws_protocol.JSON.ActiveConnectionsRegistry; import server.logic.ws_protocol.JSON.ConnectionContext; import server.logic.ws_protocol.JSON.entyties.Net_Request; import server.logic.ws_protocol.JSON.entyties.Net_Response; @@ -12,10 +9,7 @@ import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler; import server.logic.ws_protocol.JSON.handlers.auth.entyties.Net_CloseActiveSession_Request; import server.logic.ws_protocol.JSON.handlers.auth.entyties.Net_CloseActiveSession_Response; import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory; -import server.logic.ws_protocol.JSON.push.WsEventSender; -import server.logic.ws_protocol.JSON.utils.NetIdGenerator; import server.logic.ws_protocol.WireCodes; -import server.ws.WsConnectionUtils; import shine.db.dao.ActiveSessionsDAO; import shine.db.entities.ActiveSessionEntry; import shine.db.entities.CurrentUserEntry; @@ -36,7 +30,6 @@ import java.sql.SQLException; public class Net_CloseActiveSession_Handler implements JsonMessageHandler { private static final Logger log = LoggerFactory.getLogger(Net_CloseActiveSession_Handler.class); - private static final ObjectMapper MAPPER = new ObjectMapper(); @Override public Net_Response handle(Net_Request baseReq, ConnectionContext ctx) throws Exception { @@ -103,7 +96,7 @@ public class Net_CloseActiveSession_Handler implements JsonMessageHandler { boolean isCurrentSession = targetSessionId.equals(ctx.getSessionId()); - closeActiveSession(targetSessionId, ctx, isCurrentSession); + closeActiveSession(targetSessionId, isCurrentSession); Net_CloseActiveSession_Response resp = new Net_CloseActiveSession_Response(); resp.setOp(req.getOp()); @@ -113,7 +106,6 @@ public class Net_CloseActiveSession_Handler implements JsonMessageHandler { } private void closeActiveSession(String targetSessionId, - ConnectionContext currentCtx, boolean isCurrentSession) { try { @@ -122,32 +114,20 @@ public class Net_CloseActiveSession_Handler implements JsonMessageHandler { log.error("Ошибка БД при удалении сессии sessionId={}", targetSessionId, e); } - ConnectionContext ctxToClose = - ActiveConnectionsRegistry.getInstance().getBySessionId(targetSessionId); - - if (ctxToClose == null) return; - - String eventId = NetIdGenerator.eventId("evt"); - ObjectNode payload = MAPPER.createObjectNode(); - payload.put("eventId", eventId); - payload.put("sessionId", targetSessionId); - payload.put("reason", "closed_from_another_device"); - payload.put("timeMs", System.currentTimeMillis()); - WsEventSender.sendEvent(ctxToClose, "SessionRevoked", eventId, payload); - - if (isCurrentSession && ctxToClose == currentCtx) { + if (isCurrentSession) { + // Для текущей сессии даём ответу успеть уйти клиенту. new Thread(() -> { try { Thread.sleep(50); } catch (InterruptedException ignored) {} - WsConnectionUtils.closeConnection( - ctxToClose, - 4000, + SessionRevocationSupport.revokeConnection( + targetSessionId, + "closed_from_another_device", "Session closed by client via CloseActiveSession" ); }, "CloseSession-" + targetSessionId).start(); } else { - WsConnectionUtils.closeConnection( - ctxToClose, - 4000, + SessionRevocationSupport.revokeConnection( + targetSessionId, + "closed_from_another_device", "Session closed by client via CloseActiveSession" ); } diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/Net_CloseOtherSessions_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/Net_CloseOtherSessions_Handler.java new file mode 100644 index 00000000..580b46ee --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/Net_CloseOtherSessions_Handler.java @@ -0,0 +1,44 @@ +package server.logic.ws_protocol.JSON.handlers.auth; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import server.logic.ws_protocol.JSON.ConnectionContext; +import server.logic.ws_protocol.JSON.entyties.Net_Request; +import server.logic.ws_protocol.JSON.entyties.Net_Response; +import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler; +import server.logic.ws_protocol.JSON.handlers.auth.entyties.Net_CloseOtherSessions_Request; +import server.logic.ws_protocol.JSON.handlers.auth.entyties.Net_CloseOtherSessions_Response; +import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory; +import server.logic.ws_protocol.WireCodes; + +import java.util.List; + +/** Закрывает все остальные сессии пользователя одним запросом. */ +public final class Net_CloseOtherSessions_Handler implements JsonMessageHandler { + private static final Logger log = LoggerFactory.getLogger(Net_CloseOtherSessions_Handler.class); + + @Override + public Net_Response handle(Net_Request baseReq, ConnectionContext ctx) { + Net_CloseOtherSessions_Request req = (Net_CloseOtherSessions_Request) baseReq; + if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank() + || ctx.getSessionId() == null || ctx.getSessionId().isBlank()) { + return NetExceptionResponseFactory.error(req, WireCodes.Status.UNVERIFIED, + "NOT_AUTHENTICATED", "Операция доступна только для авторизованной сессии"); + } + try { + List ids = SessionRevocationSupport.deleteOtherSessions(ctx.getLogin().trim(), ctx.getSessionId()); + SessionRevocationSupport.revokeConnections(ids, "closed_other_sessions", + "Session closed by CloseOtherSessions"); + Net_CloseOtherSessions_Response resp = new Net_CloseOtherSessions_Response(); + resp.setOp(req.getOp()); + resp.setRequestId(req.getRequestId()); + resp.setStatus(WireCodes.Status.OK); + resp.setClosedCount(ids.size()); + return resp; + } catch (Exception e) { + log.error("CloseOtherSessions failed login={}", ctx.getLogin(), e); + return NetExceptionResponseFactory.error(req, WireCodes.Status.SERVER_DATA_ERROR, + "DB_ERROR", "Не удалось закрыть остальные сессии"); + } + } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/SessionRevocationSupport.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/SessionRevocationSupport.java new file mode 100644 index 00000000..30b604c1 --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/SessionRevocationSupport.java @@ -0,0 +1,49 @@ +package server.logic.ws_protocol.JSON.handlers.auth; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.node.ObjectNode; +import server.logic.ws_protocol.JSON.ActiveConnectionsRegistry; +import server.logic.ws_protocol.JSON.ConnectionContext; +import server.logic.ws_protocol.JSON.push.WsEventSender; +import server.logic.ws_protocol.JSON.utils.NetIdGenerator; +import server.ws.WsConnectionUtils; +import shine.db.dao.ActiveSessionsDAO; + +import java.sql.Connection; +import java.sql.SQLException; +import java.util.List; + +/** Общая логика отзыва пользовательских сессий. */ +public final class SessionRevocationSupport { + private static final ObjectMapper MAPPER = new ObjectMapper(); + + private SessionRevocationSupport() {} + + public static List deleteOtherSessions(Connection c, String login, String keepSessionId) throws SQLException { + return ActiveSessionsDAO.getInstance().deleteOtherSessions(c, login, keepSessionId); + } + + public static List deleteOtherSessions(String login, String keepSessionId) throws SQLException { + return ActiveSessionsDAO.getInstance().deleteOtherSessions(login, keepSessionId); + } + + public static void revokeConnections(List sessionIds, String reason, String closeReason) { + if (sessionIds == null) return; + for (String sessionId : sessionIds) { + revokeConnection(sessionId, reason, closeReason); + } + } + + public static void revokeConnection(String sessionId, String reason, String closeReason) { + ConnectionContext target = ActiveConnectionsRegistry.getInstance().getBySessionId(sessionId); + if (target == null) return; + String eventId = NetIdGenerator.eventId("evt"); + ObjectNode payload = MAPPER.createObjectNode(); + payload.put("eventId", eventId); + payload.put("sessionId", sessionId); + payload.put("reason", reason == null ? "session_revoked" : reason); + payload.put("timeMs", System.currentTimeMillis()); + WsEventSender.sendEvent(target, "SessionRevoked", eventId, payload); + WsConnectionUtils.closeConnection(target, 4000, closeReason == null ? "Session revoked" : closeReason); + } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/SolanaUserPdaImportService.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/SolanaUserPdaImportService.java index 00d4a33f..b4b46158 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/SolanaUserPdaImportService.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/SolanaUserPdaImportService.java @@ -252,7 +252,7 @@ public final class SolanaUserPdaImportService { c = payloadEnd; } - if (blockchainKey32 == null || clientKey32 == null || forkCount <= 0) return null; + if (blockchainKey32 == null || clientKey32 == null || forkCount <= 0 || forkCount > 999) return null; String blockchainName = login + "-" + String.format(Locale.ROOT, "%03d", forkCount); return new ParsedSolanaUser( login, diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/entyties/Net_CloseOtherSessions_Request.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/entyties/Net_CloseOtherSessions_Request.java new file mode 100644 index 00000000..f869a097 --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/entyties/Net_CloseOtherSessions_Request.java @@ -0,0 +1,7 @@ +package server.logic.ws_protocol.JSON.handlers.auth.entyties; + +import server.logic.ws_protocol.JSON.entyties.Net_Request; + +/** Закрыть все активные сессии текущего пользователя, кроме текущей. */ +public final class Net_CloseOtherSessions_Request extends Net_Request { +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/entyties/Net_CloseOtherSessions_Response.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/entyties/Net_CloseOtherSessions_Response.java new file mode 100644 index 00000000..8ded9d81 --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/entyties/Net_CloseOtherSessions_Response.java @@ -0,0 +1,9 @@ +package server.logic.ws_protocol.JSON.handlers.auth.entyties; + +import server.logic.ws_protocol.JSON.entyties.Net_Response; + +public final class Net_CloseOtherSessions_Response extends Net_Response { + private int closedCount; + public int getClosedCount() { return closedCount; } + public void setClosedCount(int closedCount) { this.closedCount = closedCount; } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_AddBlock_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_AddBlock_Handler.java index 77663501..d1005a46 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_AddBlock_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_AddBlock_Handler.java @@ -3,10 +3,13 @@ package server.logic.ws_protocol.JSON.handlers.blockchain; import blockchain.BchBlockEntry; import blockchain.BchCryptoVerifier; import blockchain.MsgSubType; +import blockchain.ShineProtocolTags; import blockchain.body.BodyHasLine; import blockchain.body.BodyHasTarget; import blockchain.body.ConnectionBody; import blockchain.body.CreateChannelBody; +import blockchain.body.HeaderBody; +import blockchain.body.ForkBody; import blockchain.body.StatusActionBody; import blockchain.body.TextReplyBody; import blockchain.body.TextLineBody; @@ -28,10 +31,11 @@ import server.logic.ws_protocol.JSON.handlers.channels.ChannelMetaTextParser; import server.logic.ws_protocol.JSON.handlers.channels.ChannelNamesStateBootstrapper; import server.logic.ws_protocol.JSON.handlers.channels.UserCountersSupport; import server.logic.ws_protocol.WireCodes; -import server.sync.AddBlockSyncService; +import server.sync.ArweavePublishSignal; import shine.db.channels.ChannelNameRules; import shine.db.dao.BlockchainStateDAO; import shine.db.dao.BlocksDAO; +import shine.db.dao.CanonicalChainResolver; import shine.db.dao.ChannelNameStateDAO; import shine.db.dao.UserNotificationsStateDAO; import shine.db.dao.UserParamsDAO; @@ -62,10 +66,10 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { private static final Logger log = LoggerFactory.getLogger(Net_AddBlock_Handler.class); private final BlocksDAO blocksDAO = BlocksDAO.getInstance(); + private final CanonicalChainResolver canonicalChain = CanonicalChainResolver.getInstance(); private final BlockchainStateDAO stateDAO = BlockchainStateDAO.getInstance(); private final UserParamsDAO userParamsDAO = UserParamsDAO.getInstance(); private final ChannelNameStateDAO channelNameStateDAO = ChannelNameStateDAO.getInstance(); - private final AddBlockSyncService addBlockSyncService = new AddBlockSyncService(); private final BlockchainWriter dbWriter = new BlockchainWriter( blocksDAO, stateDAO, userParamsDAO, channelNameStateDAO, UserNotificationsStateDAO.getInstance()); @@ -98,13 +102,26 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { ReentrantLock lock = BlockchainLocks.lockFor(blockchainName); lock.lock(); try { + try { + if (isKeyRotationActive(blockchainName)) { + BlockchainStateEntry currentState = stateDAO.getByBlockchainName(blockchainName); + int lastNum = currentState != null ? currentState.getLastBlockNumber() : -1; + String lastHash = currentState != null ? toHex(currentState.getLastBlockHash()) : ""; + return error(req, 423, "key_rotation_in_progress", lastNum, lastHash); + } + } catch (Exception e) { + log.error("AddBlock: не удалось проверить key rotation status для {}", blockchainName, e); + return error(req, WireCodes.Status.INTERNAL_ERROR, "key_rotation_check_failed", -1, ""); + } + AddBlockResult r = addBlock( blockchainName, req.getBlockNumber(), // старое поле, пока оставляем req.getPrevBlockHash(), // старое поле, пока оставляем req.getBlockBytesB64(), true, - true + true, + false ); // ✅ УСПЕХ: как раньше @@ -152,6 +169,23 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { return resp; } + private boolean isKeyRotationActive(String blockchainName) throws java.sql.SQLException { + String login = BlockchainNameUtil.loginFromBlockchainName(blockchainName); + if (login == null || login.isBlank()) return false; + try (Connection c = shine.db.DbController.getInstance().getConnection(); + PreparedStatement ps = c.prepareStatement(""" + SELECT rotation_status + FROM solana_user_pda_current + WHERE normalized_login = LOWER(BTRIM(?)) + LIMIT 1 + """)) { + ps.setString(1, login); + try (ResultSet rs = ps.executeQuery()) { + return rs.next() && !"NONE".equals(rs.getString(1)); + } + } + } + private static String humanMessage(String code) { if (code == null) return "Ошибка добавления блока"; return switch (code) { @@ -165,18 +199,27 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { case "limit_check_failed" -> "Ошибка проверки лимита размера"; case "bad_block_format" -> "Некорректный формат блока"; case "bad_app_tag" -> "Некорректный тестовый тег ANS-104"; + case "bad_type_tag" -> "Некорректный индексный t-тег ANS-104"; case "bad_channel_tag" -> "Некорректный тег канала ANS-104"; case "bad_block_body" -> "Некорректное тело блока"; case "bad_channel_name" -> "Некорректное название канала"; case "bad_block_number" -> "Некорректный номер блока"; case "req_global_mismatch" -> "Номер блока в запросе не совпадает с номером в блоке"; case "bad_prev_hash" -> "Некорректный prevHash (цепочка не совпадает)"; + case "bad_back32_hash" -> "Некорректный back32Hash (резервная ссылка N-32 не совпадает)"; + case "db_error_back32_check" -> "Ошибка БД при проверке back32Hash"; case "bad_blockchain_key_len" -> "Некорректный ключ блокчейна в состоянии (ожидалось 32 байта)"; case "signature_verify_failed" -> "Ошибка проверки подписи блока"; case "bad_signature" -> "Некорректная подпись блока"; - case "prev_line_block_not_found" -> "Не найден блок prevLineNumber для проверки линии"; + case "prev_line_block_not_found", "line_root_not_found" -> "Не найден root/prev блок логической линии"; + case "bad_line_code" -> "Некорректный код логической линии"; + case "bad_line_root" -> "Некорректный root логической линии"; + case "bad_line_state" -> "Повреждено состояние логической линии"; + case "bad_prev_line_number" -> "Блок не продолжает текущий хвост логической линии"; case "bad_prev_line_hash" -> "Некорректный prevLineHash"; - case "db_error_prev_line_check" -> "Ошибка БД при проверке prevLine"; + case "bad_line_sequence" -> "Некорректный порядковый номер логической линии"; + case "unsupported_line_body" -> "Этот body не поддерживает логическую линию"; + case "db_error_prev_line_check", "db_error_line_check" -> "Ошибка БД при проверке логической линии"; case "channel_name_already_exists" -> "Такое название канала уже занято"; case "repost_disabled" -> "Репосты временно отключены до будущей реализации"; case "entrypoint_edit_forbidden" -> "TEXT_ENTRYPOINT нельзя редактировать через TEXT_EDIT_POST"; @@ -184,6 +227,8 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { case "status_action_target_not_allowed" -> "Этот STATUS_ACTION нельзя ставить на выбранный тип материала"; case "internal_error" -> "Внутренняя ошибка сервера при записи блока"; case "chain_resync_in_progress" -> "Цепочка сейчас пересинхронизируется"; + case "key_rotation_in_progress" -> "Сейчас выполняется смена ключей; обычные новые блоки временно запрещены"; + case "key_rotation_check_failed" -> "Не удалось проверить состояние смены ключей"; default -> "Ошибка: " + code; }; } @@ -194,7 +239,8 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { String prevGlobalHashHexFromReq, String blockBytesB64, boolean replicateAfterWrite, - boolean publishToArweave + boolean publishToArweave, + boolean replayMode ) { if (blockchainName == null || blockchainName.isBlank()) { log.warn("AddBlock: пустой blockchainName (reqGlobalNumber={})", globalNumberFromReq); @@ -276,10 +322,21 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_block_format", serverLastNum, serverLastHashHex); } - if (!block.getDataItem().hasTag("App", "test5590")) { + if (!block.getDataItem().hasTag(ShineProtocolTags.APP_TAG_NAME, ShineProtocolTags.APP_TAG_VALUE)) { return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_app_tag", serverLastNum, serverLastHashHex); } + // Signed secondary index for the fixed SHiNE streams. + String expectedTypeTag = expectedTypeTag(block); + String actualTypeTag = block.getDataItem().tagValue(ShineProtocolTags.TYPE_TAG_NAME); + if (expectedTypeTag != null) { + if (!expectedTypeTag.equals(actualTypeTag)) { + return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_type_tag", serverLastNum, serverLastHashHex); + } + } else if (actualTypeTag != null) { + return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_type_tag", serverLastNum, serverLastHashHex); + } + // body.check() try { block.body.check(); @@ -289,6 +346,18 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_block_body", serverLastNum, serverLastHashHex); } + // Canonical chain bootstrap: block #0 is always HEADER. + if (serverLastNum == -1) { + if (!(block.body instanceof HeaderBody headerBody)) { + return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "header_required_as_block_zero", serverLastNum, serverLastHashHex); + } + if (!login.equals(headerBody.login)) { + return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "header_login_mismatch", serverLastNum, serverLastHashHex); + } + } else if (block.body instanceof HeaderBody) { + return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "header_must_be_block_zero", serverLastNum, serverLastHashHex); + } + // Репосты временно отключены до будущей реализации. // Точка возврата: docs/Future_Features/2026-05-24_1140_репосты_в_каналах_и_тредах.md if ((block.type & 0xFFFF) == 1 @@ -300,7 +369,6 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { ChannelNameStateEntry channelNameStateEntry = null; ChannelNameStateEntry channelMetaUpdateEntry = null; - Chat200CreateSeed chat200CreateSeed = null; if (block.body instanceof CreateChannelBody createChannelBody) { int channelTypeCode = Short.toUnsignedInt(createChannelBody.channelTypeCode); int channelTypeVersion = Short.toUnsignedInt(createChannelBody.channelTypeVersion); @@ -363,17 +431,7 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { channelNameStateEntry.setChannelRootBlockHash(block.getHash32()); channelNameStateEntry.setCreatedAtMs(block.timestamp * 1000L); - if (channelTypeCode == (CreateChannelBody.CHANNEL_TYPE_GROUP & 0xFFFF)) { - chat200CreateSeed = new Chat200CreateSeed(); - chat200CreateSeed.ownerLogin = login; - chat200CreateSeed.ownerBch = blockchainName; - chat200CreateSeed.rootBlockNumber = block.blockNumber; - chat200CreateSeed.rootBlockHash = block.getHash32(); - chat200CreateSeed.channelName = normalizedName; - chat200CreateSeed.channelTypeVersion = channelTypeVersion; - chat200CreateSeed.chatTitle = channelNameStateEntry.getChannelDescription(); - chat200CreateSeed.updatedAtMs = block.timestamp * 1000L; - } + // Chat200 group projection intentionally retired; legacy helpers remain @Deprecated only. } else if ((block.type & 0xFFFF) == 1 && (block.subType & 0xFFFF) == (MsgSubType.TEXT_CHANNEL_META & 0xFFFF) && block.body instanceof TextLineBody metaBody) { @@ -399,6 +457,7 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { return new AddBlockResult(WireCodes.Status.BAD_REQUEST, e.getMessage(), serverLastNum, serverLastHashHex); } channelMetaUpdateEntry = new ChannelNameStateEntry(); + channelMetaUpdateEntry.setOwnerLogin(login); channelMetaUpdateEntry.setOwnerBlockchainName(blockchainName); channelMetaUpdateEntry.setChannelRootBlockNumber(lineCode); channelMetaUpdateEntry.setDisplayName(parsedMeta.title()); @@ -409,10 +468,10 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { channelMetaUpdateEntry.setMetaUpdatedAtMs(block.timestamp * 1000L); } - // Channel DataItems are indexed by a signed canonical channel slug tag: c_test5590=. + // Channel DataItems are indexed by a signed canonical channel slug tag: c=. try { String expectedChannelSlug = expectedChannelSlug(blockchainName, block, channelNameStateEntry); - String actualChannelSlug = block.getDataItem().tagValue("c_test5590"); + String actualChannelSlug = block.getDataItem().tagValue(ShineProtocolTags.CHANNEL_TAG_NAME); if (expectedChannelSlug != null) { if (!expectedChannelSlug.equals(actualChannelSlug)) { return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_channel_tag", serverLastNum, serverLastHashHex); @@ -439,6 +498,20 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { } } + if ((block.type & 0xFFFF) == 1 + && (block.subType & 0xFFFF) == (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF)) { + try { + String editError = validateEditReplyTarget(blockchainName, block); + if (editError != null) { + return new AddBlockResult(WireCodes.Status.BAD_REQUEST, editError, serverLastNum, serverLastHashHex); + } + } catch (Exception e) { + log.error("AddBlock: edit_reply_target_check_failed (login={}, blockchainName={}, blockNumber={})", + login, blockchainName, block.blockNumber, e); + return new AddBlockResult(WireCodes.Status.INTERNAL_ERROR, "internal_error", serverLastNum, serverLastHashHex); + } + } + if ((block.type & 0xFFFF) == 5) { try { String statusError = validateStatusActionTarget(block); @@ -474,6 +547,29 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_prev_hash", serverLastNum, serverLastHashHex); } + // 4.4) резервная глобальная ссылка: N<32 -> ZERO32, иначе hash блока N-32. + try { + byte[] expectedBack32 = new byte[32]; + if (block.blockNumber >= 32) { + byte[] storedBack32 = canonicalChain.getHash(blockchainName, block.blockNumber - 32); + if (storedBack32 == null || storedBack32.length != 32) { + log.error("AddBlock: missing N-32 block for back32 validation (blockchainName={}, blockNumber={}, target={})", + blockchainName, block.blockNumber, block.blockNumber - 32); + return new AddBlockResult(WireCodes.Status.INTERNAL_ERROR, "db_error_back32_check", serverLastNum, serverLastHashHex); + } + expectedBack32 = storedBack32; + } + if (!Arrays.equals(block.back32Hash32, expectedBack32)) { + log.warn("AddBlock: bad_back32_hash (login={}, blockchainName={}, blockNumber={}, clientBack32={}, expectedBack32={})", + login, blockchainName, block.blockNumber, toHex(block.back32Hash32), toHex(expectedBack32)); + return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_back32_hash", serverLastNum, serverLastHashHex); + } + } catch (Exception e) { + log.error("AddBlock: db_error_back32_check (login={}, blockchainName={}, blockNumber={})", + login, blockchainName, block.blockNumber, e); + return new AddBlockResult(WireCodes.Status.INTERNAL_ERROR, "db_error_back32_check", serverLastNum, serverLastHashHex); + } + // 5) pubKey final byte[] pubKey32 = st.getBlockchainKeyBytes(); if (pubKey32 == null || pubKey32.length != 32) { @@ -482,6 +578,11 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_blockchain_key_len", serverLastNum, serverLastHashHex); } + if (serverLastNum == -1 && block.body instanceof HeaderBody headerBody + && !Arrays.equals(headerBody.initialBlockchainKey32, pubKey32)) { + return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "header_initial_key_mismatch", serverLastNum, serverLastHashHex); + } + // 6) ANS-104 Ed25519 подпись и owner boolean sigOk; try { @@ -498,7 +599,7 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_signature", serverLastNum, serverLastHashHex); } - // 7) line columns (only for BodyHasLine) + // 7) line columns + strict continuity check. Integer lineCode = null; Integer prevLineNumber = null; byte[] prevLineHash32 = null; @@ -510,33 +611,17 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { prevLineHash32 = bl.prevLineBlockHash32(); thisLineNumber = bl.lineSeq(); - // Нормализация: -1 не пишем в БД (для совместимости со старым TextBody) - if (prevLineNumber != null && prevLineNumber == -1) { - lineCode = null; - prevLineNumber = null; - prevLineHash32 = null; - thisLineNumber = null; - } - - // Если prevLineNumber задан — проверяем его хэш - if (prevLineNumber != null) { - try { - byte[] dbPrevHash = blocksDAO.getHashByNumber(blockchainName, prevLineNumber); - if (dbPrevHash == null) { - log.warn("AddBlock: prev_line_block_not_found (login={}, blockchainName={}, blockNumber={}, prevLineNumber={})", - login, blockchainName, block.blockNumber, prevLineNumber); - return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "prev_line_block_not_found", serverLastNum, serverLastHashHex); - } - if (!Arrays.equals(dbPrevHash, require32OrThrow(prevLineHash32, "prevLineHash32 invalid"))) { - log.warn("AddBlock: bad_prev_line_hash (login={}, blockchainName={}, blockNumber={}, prevLineNumber={})", - login, blockchainName, block.blockNumber, prevLineNumber); - return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_prev_line_hash", serverLastNum, serverLastHashHex); - } - } catch (Exception e) { - log.error("AddBlock: db_error_prev_line_check (login={}, blockchainName={}, blockNumber={})", - login, blockchainName, block.blockNumber, e); - return new AddBlockResult(WireCodes.Status.INTERNAL_ERROR, "db_error_prev_line_check", serverLastNum, serverLastHashHex); + try { + String lineError = validateLineContinuity(blockchainName, block, bl); + if (lineError != null) { + log.warn("AddBlock: {} (login={}, blockchainName={}, blockNumber={}, lineCode={}, prevLineNumber={}, lineSeq={})", + lineError, login, blockchainName, block.blockNumber, lineCode, prevLineNumber, thisLineNumber); + return new AddBlockResult(WireCodes.Status.BAD_REQUEST, lineError, serverLastNum, serverLastHashHex); } + } catch (Exception e) { + log.error("AddBlock: db_error_line_check (login={}, blockchainName={}, blockNumber={})", + login, blockchainName, block.blockNumber, e); + return new AddBlockResult(WireCodes.Status.INTERNAL_ERROR, "db_error_line_check", serverLastNum, serverLastHashHex); } } @@ -544,7 +629,7 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { try { BlockEntry be = new BlockEntry(); be.setLogin(login); - be.setBchName(blockchainName); + be.setForkNumber(java.util.Objects.requireNonNull(BlockchainNameUtil.forkNumberFromBlockchainName(blockchainName), "invalid blockchainName fork")); be.setBlockNumber(block.blockNumber); be.setMsgType(block.type & 0xFFFF); @@ -562,28 +647,29 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { be.setPrevLineHash(prevLineHash32); be.setThisLineNumber(thisLineNumber); - // target columns (optional) + // target columns (optional). Signed identity is login + blockNumber + blockHash. + // toForkNumber is historical metadata only and never participates in target identity. if (block.body instanceof BodyHasTarget t) { - String targetBchName = t.toBchName(); int type = block.type & 0xFFFF; int sub = block.subType & 0xFFFF; boolean isTextEdit = type == 1 && (sub == (MsgSubType.TEXT_EDIT_POST & 0xFFFF) || sub == (MsgSubType.TEXT_EDIT_REPLY & 0xFFFF)); - if (isTextEdit && (targetBchName == null || targetBchName.isBlank())) { - targetBchName = blockchainName; + + String targetLogin = t.toLogin(); + Integer targetForkNumber = t.toForkNumber(); + if (isTextEdit) { + // EDIT target is compact and belongs to this logical user history; physical fork is resolved canonically. + targetLogin = login; + targetForkNumber = null; } - be.setToLogin(t.toLogin()); - be.setToBchName(targetBchName); + be.setToLogin(targetLogin); + be.setToForkNumber(targetForkNumber); be.setToBlockNumber(t.toBlockGlobalNumber()); be.setToBlockHash(t.toBlockHashBytes()); - - if (isTextEdit && (be.getToLogin() == null || be.getToLogin().isBlank()) && targetBchName != null && !targetBchName.isBlank()) { - be.setToLogin(BlockchainNameUtil.loginFromBlockchainName(targetBchName)); - } } - // edit helper (optional): если TEXT_EDIT_* — это "редактирование блока цели" + // edit helper (optional): TEXT_EDIT_* targets are resolved against logical canonical history int type = block.type & 0xFFFF; int sub = block.subType & 0xFFFF; @@ -617,16 +703,21 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { UserNotificationEntry notificationEntry = buildNotificationEntry(block, be); List counterChangedLogins = dbWriter.appendBlockAndState( - blockchainName, block, st, be, upsertedParam, channelNameStateEntry, channelMetaUpdateEntry, notificationEntry); + blockchainName, block, st, be, upsertedParam, channelNameStateEntry, channelMetaUpdateEntry, notificationEntry, replayMode); - for (String changedLogin : counterChangedLogins) { - UserCountersSupport.pushChanged(changedLogin); + if (!replayMode) { + for (String changedLogin : counterChangedLogins) { + UserCountersSupport.pushChanged(changedLogin); + } } - if (chat200CreateSeed != null) { - upsertChat200StateFromCreate(chat200CreateSeed); + // Chat200 is legacy/non-working/unused. Do not create or mutate Chat200 projections. + // The historical helper code remains below only for archive compatibility and may be removed later. + + if (publishToArweave) { + // Только ставим быструю публикацию в очередь: ответ клиенту не ждёт сеть Turbo/Arweave. + ArweavePublishSignal.userBlockAccepted(be.getDataItemId()); } - maybeApplyChat200Command(blockchainName, block); } catch (Exception e) { if (isChannelSlugConflict(e)) { return new AddBlockResult(409, "channel_name_already_exists", serverLastNum, serverLastHashHex); @@ -641,9 +732,8 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { log.info("✅ AddBlock ok: login={}, blockchainName={}, blockNumber={}, newHash={}", login, blockchainName, block.blockNumber, newHashHex); - if (replicateAfterWrite) { - addBlockSyncService.replicateAsync(blockchainName, block.blockNumber); - } + // Legacy server-to-server replication is intentionally disabled. + // Arweave/Turbo is the supported cross-server recovery/synchronization source. return new AddBlockResult(WireCodes.Status.OK, null, block.blockNumber, newHashHex); } @@ -653,7 +743,16 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { * но не запускает повторную межсерверную репликацию уже импортированного блока. */ public ArweaveImportResult addBlockFromArweave(String blockchainName, byte[] rawBlockBytes) { - if (BlockchainResyncGuard.isBlockedForExternalAddBlock(blockchainName)) { + return addBlockFromStoredBytes(blockchainName, rawBlockBytes, false); + } + + /** Deterministic local replay: rebuild SQL projections without live notifications/unread/push side effects. */ + public ArweaveImportResult addBlockFromReplay(String blockchainName, byte[] rawBlockBytes) { + return addBlockFromStoredBytes(blockchainName, rawBlockBytes, true); + } + + private ArweaveImportResult addBlockFromStoredBytes(String blockchainName, byte[] rawBlockBytes, boolean replayMode) { + if (!replayMode && BlockchainResyncGuard.isBlockedForExternalAddBlock(blockchainName)) { return new ArweaveImportResult(false, "chain_resync_in_progress", -1, ""); } if (rawBlockBytes == null || rawBlockBytes.length == 0) { @@ -682,7 +781,8 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { toHex(parsed.prevHash32), Base64Ws.encode(rawBlockBytes), false, - false + false, + replayMode ); return new ArweaveImportResult(r.isOk(), r.reasonCode, r.serverLastBlockNumber, r.serverLastBlockHashHex); } finally { @@ -696,6 +796,84 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { /* ====================== Helpers ====================================== */ /* ===================================================================== */ + private static String expectedTypeTag(BchBlockEntry block) { + int type = block.type & 0xffff; + return switch (type) { + case 0 -> "tech"; + case 3 -> "conn"; + case 4 -> "prof"; + default -> null; + }; + } + + /** + * Проверяет не просто существование prev-блока, а именно продолжение текущего хвоста линии. + * Это запрещает боковые ветки линии и гарантирует монотонный sequence. + */ + private String validateLineContinuity(String blockchainName, BchBlockEntry block, BodyHasLine line) throws Exception { + int type = block.type & 0xffff; + int lineCode = line.lineCode(); + int rootBlockNumber; + int firstSequence; + + if (block.body instanceof UserParamBody || block.body instanceof ConnectionBody) { + if (lineCode != 0) return "bad_line_code"; + rootBlockNumber = 0; + firstSequence = 1; + } else if (block.body instanceof CreateChannelBody || block.body instanceof ForkBody) { + if (lineCode != 0) return "bad_line_code"; + rootBlockNumber = 0; + firstSequence = 1; + } else if (block.body instanceof TextLineBody) { + if (lineCode < 0) return "bad_line_code"; + rootBlockNumber = lineCode; + // Channel sequence is zero-based after its root anchor. + firstSequence = 0; + } else { + return "unsupported_line_body"; + } + + BlockEntry root = canonicalChain.getBlock(blockchainName, rootBlockNumber); + if (root == null) return "line_root_not_found"; + if (rootBlockNumber == 0) { + try { + if (!(new BchBlockEntry(root.getBlockBytes()).body instanceof HeaderBody)) return "bad_line_root"; + } catch (Exception e) { + return "bad_line_root"; + } + } else { + try { + if (!(new BchBlockEntry(root.getBlockBytes()).body instanceof CreateChannelBody)) return "bad_line_root"; + } catch (Exception e) { + return "bad_line_root"; + } + } + + BlockEntry tail; + try (Connection resolverConnection = shine.db.DbController.getInstance().getConnection()) { + tail = canonicalChain.getLastLineBlock(resolverConnection, blockchainName, type, lineCode, block.blockNumber); + } + int expectedPrevNumber; + byte[] expectedPrevHash; + int expectedSequence; + if (tail == null) { + expectedPrevNumber = rootBlockNumber; + expectedPrevHash = root.getBlockHash(); + expectedSequence = firstSequence; + } else { + if (tail.getThisLineNumber() == null) return "bad_line_state"; + expectedPrevNumber = tail.getBlockNumber(); + expectedPrevHash = tail.getBlockHash(); + expectedSequence = Math.addExact(tail.getThisLineNumber(), 1); + } + + if (line.prevLineBlockGlobalNumber() != expectedPrevNumber) return "bad_prev_line_number"; + byte[] suppliedPrevHash = require32OrThrow(line.prevLineBlockHash32(), "prevLineHash32 invalid"); + if (!Arrays.equals(expectedPrevHash, suppliedPrevHash)) return "bad_prev_line_hash"; + if (line.lineSeq() != expectedSequence) return "bad_line_sequence"; + return null; + } + private String expectedChannelSlug(String blockchainName, BchBlockEntry block, ChannelNameStateEntry justCreated) throws Exception { if (block.body instanceof CreateChannelBody) { return justCreated == null ? null : justCreated.getSlug(); @@ -706,6 +884,7 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { sub == (MsgSubType.TEXT_POST & 0xffff) || sub == (MsgSubType.TEXT_REPOST & 0xffff) || sub == (MsgSubType.TEXT_CHANNEL_META & 0xffff) + || sub == (MsgSubType.TEXT_CHANNEL_DELETE & 0xffff) || sub == (MsgSubType.TEXT_ENTRYPOINT & 0xffff) || sub == (MsgSubType.TEXT_EXERCISE & 0xffff) || sub == (MsgSubType.TEXT_SERVICE & 0xffff) @@ -759,6 +938,8 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { return false; } + /** @deprecated Chat200 is legacy/non-working/unused. */ + @Deprecated private static final class Chat200CreateSeed { String ownerLogin; String ownerBch; @@ -775,41 +956,58 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { } private String validateEditPostTarget(String ownerBch, BchBlockEntry block) throws Exception { - if (!(block.body instanceof TextLineBody editBody)) return null; + if (!(block.body instanceof TextLineBody editBody)) return "bad_block_body"; Integer targetBlockNumber = editBody.toBlockGlobalNumber(); byte[] targetHash = editBody.toBlockHashBytes(); if (targetBlockNumber == null || targetHash == null || targetHash.length != 32) return "bad_block_body"; - BlockEntry target = blocksDAO.getByNumber(ownerBch, targetBlockNumber); + BlockEntry target = canonicalChain.getBlock(ownerBch, targetBlockNumber); if (target == null || target.getBlockHash() == null || !Arrays.equals(target.getBlockHash(), targetHash)) { - return null; + return "edit_target_not_found"; } - if (target.getMsgType() != 1) return null; - if (target.getMsgSubType() == (MsgSubType.TEXT_ENTRYPOINT & 0xFFFF)) { - return "entrypoint_edit_forbidden"; + if (target.getMsgType() != 1 || target.getMsgSubType() != (MsgSubType.TEXT_POST & 0xFFFF)) { + return "edit_post_target_must_be_text_post"; + } + return null; + } + + private String validateEditReplyTarget(String ownerBch, BchBlockEntry block) throws Exception { + if (!(block.body instanceof TextReplyBody editBody)) return "bad_block_body"; + Integer targetBlockNumber = editBody.toBlockGlobalNumber(); + byte[] targetHash = editBody.toBlockHashBytes(); + if (targetBlockNumber == null || targetHash == null || targetHash.length != 32) return "bad_block_body"; + + BlockEntry target = canonicalChain.getBlock(ownerBch, targetBlockNumber); + if (target == null || target.getBlockHash() == null || !Arrays.equals(target.getBlockHash(), targetHash)) { + return "edit_target_not_found"; + } + if (target.getMsgType() != 1 || target.getMsgSubType() != (MsgSubType.TEXT_REPLY & 0xFFFF)) { + return "edit_reply_target_must_be_text_reply"; } return null; } private String validateStatusActionTarget(BchBlockEntry block) throws Exception { if (!(block.body instanceof StatusActionBody statusBody)) return "bad_block_body"; - String targetBch = statusBody.toBchName(); + String targetLogin = statusBody.toLogin(); + Integer targetFork = statusBody.toForkNumber(); Integer targetBlockNumber = statusBody.toBlockGlobalNumber(); byte[] targetHash = statusBody.toBlockHashBytes(); - if (targetBch == null || targetBch.isBlank() || targetBlockNumber == null || targetHash == null || targetHash.length != 32) { + if (targetLogin == null || targetLogin.isBlank() || targetFork == null + || targetBlockNumber == null || targetHash == null || targetHash.length != 32) { return "bad_block_body"; } + // forkNumber is historical only. It is used here solely as a physical lookup hint. + if (targetFork <= 0) return null; + String targetBch = BlockchainNameUtil.blockchainName(targetLogin, targetFork); BlockEntry target = blocksDAO.getByNumber(targetBch, targetBlockNumber); if (target == null || target.getBlockHash() == null || !Arrays.equals(target.getBlockHash(), targetHash)) { return null; } int statusSubType = block.subType & 0xFFFF; if (statusSubType == (MsgSubType.STATUS_CONFIRMED & 0xFFFF)) { - if (target.getMsgType() != 5) { - return "status_confirmed_target_must_be_status_action"; - } - return null; + return target.getMsgType() == 5 ? null : "status_confirmed_target_must_be_status_action"; } if (target.getMsgType() != 1) return "status_action_target_not_allowed"; @@ -836,10 +1034,10 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { PreparedStatement ps = c.prepareStatement(""" SELECT slug FROM channel_names_state - WHERE owner_bch_name = ? AND channel_root_block_number = ? + WHERE LOWER(owner_login)=LOWER(?) AND channel_root_block_number = ? LIMIT 1 """)) { - ps.setString(1, ownerBch); + ps.setString(1, BlockchainNameUtil.loginFromBlockchainName(ownerBch)); ps.setInt(2, rootBlockNumber); try (ResultSet rs = ps.executeQuery()) { if (!rs.next()) return null; @@ -850,6 +1048,8 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { } } + /** @deprecated Chat200 is legacy/non-working/unused. */ + @Deprecated private void upsertChat200StateFromCreate(Chat200CreateSeed seed) throws Exception { try (Connection c = shine.db.DbController.getInstance().getConnection(); PreparedStatement ps = c.prepareStatement(""" @@ -877,6 +1077,8 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { } } + /** @deprecated Chat200 is legacy/non-working/unused. */ + @Deprecated private void maybeApplyChat200Command(String ownerBch, BchBlockEntry block) throws Exception { int msgType = block.type & 0xFFFF; int msgSubType = block.subType & 0xFFFF; @@ -887,6 +1089,8 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { if (lineCode == null || lineCode <= 0) return; if (!isChat200Channel(ownerBch, lineCode)) return; + BlockEntry rootPhysical = canonicalChain.getBlock(ownerBch, lineCode); + String chatOwnerBch = rootPhysical == null ? ownerBch : rootPhysical.getBchName(); CommandParsed cmd = parseChatCommand(tlb.message); if (cmd == null) return; @@ -897,11 +1101,11 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { PreparedStatement ps = c.prepareStatement(""" UPDATE chat200_state SET chat_title = ?, updated_at_ms = ? - WHERE owner_bch_name = ? AND channel_root_block_number = ? + WHERE LOWER(owner_login)=LOWER(?) AND channel_root_block_number = ? """)) { ps.setString(1, cmd.arg1 == null ? "" : cmd.arg1); ps.setLong(2, updatedAtMs); - ps.setString(3, ownerBch); + ps.setString(3, chatOwnerBch); ps.setInt(4, lineCode); ps.executeUpdate(); } @@ -925,7 +1129,7 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { updated_at_ms = excluded.updated_at_ms, updated_by_block_number = excluded.updated_by_block_number """)) { - ps.setString(1, ownerBch); + ps.setString(1, chatOwnerBch); ps.setInt(2, lineCode); ps.setString(3, memberLogin); ps.setString(4, memberChannel); @@ -936,15 +1140,17 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler { } } + /** @deprecated Chat200 is legacy/non-working/unused. */ + @Deprecated private boolean isChat200Channel(String ownerBch, int rootBlockNumber) throws Exception { try (Connection c = shine.db.DbController.getInstance().getConnection(); PreparedStatement ps = c.prepareStatement(""" SELECT channel_type_code FROM channel_names_state - WHERE owner_bch_name = ? AND channel_root_block_number = ? + WHERE LOWER(owner_login)=LOWER(?) AND channel_root_block_number = ? LIMIT 1 """)) { - ps.setString(1, ownerBch); + ps.setString(1, BlockchainNameUtil.loginFromBlockchainName(ownerBch)); ps.setInt(2, rootBlockNumber); try (ResultSet rs = ps.executeQuery()) { if (!rs.next()) return false; diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_AddBlock_Handler_utils/BlockchainWriter.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_AddBlock_Handler_utils/BlockchainWriter.java index 90e5a19a..6d8f13c3 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_AddBlock_Handler_utils/BlockchainWriter.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_AddBlock_Handler_utils/BlockchainWriter.java @@ -17,7 +17,9 @@ import shine.db.entities.UserNotificationEntry; import java.sql.Connection; import java.sql.SQLException; import java.util.ArrayList; +import java.util.LinkedHashSet; import java.util.List; +import java.util.Set; /** Stores the complete ANS-104 DataItem and all derived SHiNE state atomically in PostgreSQL. * Local .bch/tmp/marker files are intentionally not used. @@ -55,11 +57,12 @@ public final class BlockchainWriter { UserParamEntry userParamEntry, ChannelNameStateEntry channelNameStateEntry, ChannelNameStateEntry channelMetaUpdateEntry, - UserNotificationEntry notificationEntry) throws SQLException { + UserNotificationEntry notificationEntry, + boolean replayMode) throws SQLException { long nowMs = System.currentTimeMillis(); byte[] rawDataItem = block.toBytes(); - List counterChangedLogins = new ArrayList<>(); + Set counterChangedLogins = new LinkedHashSet<>(); try (Connection c = shine.db.DbController.getInstance().getConnection()) { c.setAutoCommit(false); try { @@ -79,7 +82,18 @@ public final class BlockchainWriter { int msgType = block.type & 0xFFFF; int msgSubType = block.subType & 0xFFFF; Integer lineCode = be.getLineCode(); - if (isPublicChannelPublication(msgType, msgSubType) && lineCode != null && lineCode > 0) { + boolean channelVisibilityChanged = false; + if (msgType == 1 && lineCode != null && lineCode > 0) { + if (msgSubType == (MsgSubType.TEXT_CHANNEL_DELETE & 0xFFFF)) { + channelVisibilityChanged = channelNameStateDAO.updateDeletedState( + c, blockchainName, lineCode, true, block.timestamp * 1000L, block.blockNumber); + } else if (isPublicChannelPublication(msgType, msgSubType)) { + channelVisibilityChanged = channelNameStateDAO.updateDeletedState( + c, blockchainName, lineCode, false, 0L, null); + } + if (channelVisibilityChanged) counterChangedLogins.addAll(refreshChannelVisibilityStats(c, blockchainName, lineCode)); + } + if (!replayMode && isPublicChannelPublication(msgType, msgSubType) && lineCode != null && lineCode > 0) { String channelName = channelReadStateDAO.resolvePublicChannelNameByRoot(c, blockchainName, lineCode); if (channelName != null && !channelName.isBlank()) { counterChangedLogins.addAll(channelReadStateDAO.incrementUnreadForSubscribers( @@ -87,7 +101,7 @@ public final class BlockchainWriter { } } - if (msgType == 3 + if (!replayMode && msgType == 3 && msgSubType == (MsgSubType.CONNECTION_UNFOLLOW & 0xFFFF) && be.getToBchName() != null && !be.getToBchName().isBlank() && be.getToBlockNumber() != null && be.getToBlockNumber() > 0) { @@ -106,7 +120,67 @@ public final class BlockchainWriter { try { c.setAutoCommit(true); } catch (Exception ignored) {} } } - return counterChangedLogins; + return new ArrayList<>(counterChangedLogins); + } + + private static List refreshChannelVisibilityStats(Connection c, String blockchainName, int lineCode) throws SQLException { + String sql = """ + SELECT owner_login, channel_root_block_hash + FROM channel_names_state + WHERE LOWER(owner_login)=LOWER(?) AND channel_root_block_number=? + LIMIT 1 + """; + String ownerLogin = null; + byte[] rootHash = null; + try (var ps = c.prepareStatement(sql)) { + ps.setString(1, loginFromBlockchainName(blockchainName)); + ps.setInt(2, lineCode); + try (var rs = ps.executeQuery()) { + if (rs.next()) { + ownerLogin = rs.getString("owner_login"); + rootHash = rs.getBytes("channel_root_block_hash"); + } + } + } + if (ownerLogin == null || ownerLogin.isBlank() || rootHash == null) return List.of(); + + Set affected = new LinkedHashSet<>(); + affected.add(ownerLogin); + try (var ps = c.prepareStatement("SELECT shine_refresh_user_stats(?)")) { + ps.setString(1, ownerLogin); + ps.execute(); + } + + String followersSql = """ + SELECT DISTINCT cs.login + FROM connections_state cs + WHERE cs.rel_type=? + AND LOWER(cs.to_login)=LOWER(?) + AND cs.to_block_number=? + AND cs.to_block_hash=? + """; + try (var ps = c.prepareStatement(followersSql)) { + ps.setInt(1, MsgSubType.CONNECTION_FOLLOW); + ps.setString(2, ownerLogin); + ps.setInt(3, lineCode); + ps.setBytes(4, rootHash); + try (var rs = ps.executeQuery(); var refresh = c.prepareStatement("SELECT shine_refresh_user_stats(?)")) { + while (rs.next()) { + String follower = rs.getString(1); + if (follower == null || follower.isBlank()) continue; + refresh.setString(1, follower); + refresh.execute(); + affected.add(follower); + } + } + } + return new ArrayList<>(affected); + } + + private static String loginFromBlockchainName(String blockchainName) { + if (blockchainName == null) return ""; + int dash = blockchainName.lastIndexOf('-'); + return dash > 0 ? blockchainName.substring(0, dash) : blockchainName; } private static boolean isPublicChannelPublication(int msgType, int msgSubType) { diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_GetBlockchainBlock_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_GetBlockchainBlock_Handler.java index 05bee045..2567e694 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_GetBlockchainBlock_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_GetBlockchainBlock_Handler.java @@ -21,6 +21,7 @@ public final class Net_GetBlockchainBlock_Handler implements JsonMessageHandler private static final Logger log = LoggerFactory.getLogger(Net_GetBlockchainBlock_Handler.class); private final BlocksDAO blocksDAO = BlocksDAO.getInstance(); + private final shine.db.dao.CanonicalChainResolver canonicalChain = shine.db.dao.CanonicalChainResolver.getInstance(); @Override public Net_Response handle(Net_Request baseRequest, ConnectionContext ctx) { @@ -37,7 +38,7 @@ public final class Net_GetBlockchainBlock_Handler implements JsonMessageHandler } try { - BlockEntry block = blocksDAO.getByNumber(blockchainName, req.getBlockNumber()); + BlockEntry block = canonicalChain.getBlock(blockchainName, req.getBlockNumber()); if (block == null || block.getBlockBytes() == null) { return NetExceptionResponseFactory.error( req, diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_GetMyBlockchain_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_GetMyBlockchain_Handler.java new file mode 100644 index 00000000..3e254ca0 --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_GetMyBlockchain_Handler.java @@ -0,0 +1,107 @@ +package server.logic.ws_protocol.JSON.handlers.blockchain; + +import blockchain.BchBlockEntry; +import blockchain.body.BodyHasTarget; +import server.logic.ws_protocol.Base64Ws; +import server.logic.ws_protocol.JSON.ConnectionContext; +import server.logic.ws_protocol.JSON.entyties.Net_Request; +import server.logic.ws_protocol.JSON.entyties.Net_Response; +import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler; +import server.logic.ws_protocol.JSON.handlers.blockchain.entyties.Net_GetMyBlockchain_Request; +import server.logic.ws_protocol.JSON.handlers.blockchain.entyties.Net_GetMyBlockchain_Response; +import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory; +import server.logic.ws_protocol.WireCodes; +import shine.db.dao.BlockchainStateDAO; +import shine.db.dao.CanonicalChainResolver; +import shine.db.dao.SolanaUserPdaCurrentDAO; +import shine.db.entities.BlockEntry; +import shine.db.entities.BlockchainStateEntry; +import shine.db.entities.SolanaUserPdaCurrentEntry; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +/** Authenticated, paginated current-chain view used by "Мой блокчейн" and key rotation. */ +public final class Net_GetMyBlockchain_Handler implements JsonMessageHandler { + private final CanonicalChainResolver canonical = CanonicalChainResolver.getInstance(); + private final BlockchainStateDAO states = BlockchainStateDAO.getInstance(); + private final SolanaUserPdaCurrentDAO users = SolanaUserPdaCurrentDAO.getInstance(); + + @Override + public Net_Response handle(Net_Request baseReq, ConnectionContext ctx) { + Net_GetMyBlockchain_Request req = (Net_GetMyBlockchain_Request) baseReq; + if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) { + return NetExceptionResponseFactory.error(req, 401, "AUTH_REQUIRED", "Нужна авторизованная пользовательская сессия"); + } + try { + String login = ctx.getLogin().trim(); + SolanaUserPdaCurrentEntry user = users.getByLogin(login); + if (user == null || user.getBlockchainName() == null || user.getBlockchainName().isBlank()) { + return NetExceptionResponseFactory.error(req, 404, "BLOCKCHAIN_NOT_FOUND", "Текущий блокчейн пользователя не найден"); + } + String bch = user.getBlockchainName(); + BlockchainStateEntry state = states.getByBlockchainName(bch); + int tip = state == null ? -1 : state.getLastBlockNumber(); + String tipHash = state == null ? null : hex(state.getLastBlockHash()); + int limit = req.getLimit() == null ? 50 : Math.max(1, Math.min(100, req.getLimit())); + int before = req.getBeforeBlock() == null || req.getBeforeBlock() < 0 ? tip : Math.min(tip, req.getBeforeBlock()); + boolean includeBytes = Boolean.TRUE.equals(req.getIncludeBlockBytes()); + + List rows = new ArrayList<>(); + if (before >= 0) { + int low = Math.max(0, before - limit + 1); + for (int n = before; n >= low; n--) { + BlockEntry row = canonical.getBlock(bch, n); + if (row == null) { + return NetExceptionResponseFactory.error(req, 409, "CANONICAL_HISTORY_GAP", + "В канонической истории отсутствует блок #" + n); + } + rows.add(row); + } + } + List items = new ArrayList<>(rows.size()); + for (BlockEntry row : rows) { + BchBlockEntry parsed = new BchBlockEntry(row.getBlockBytes()); + Net_GetMyBlockchain_Response.BlockItem item = new Net_GetMyBlockchain_Response.BlockItem(); + item.setBlockNumber(row.getBlockNumber()); + item.setBlockHash(hex(row.getBlockHash())); + item.setPrevBlockHash(hex(parsed.prevHash32)); + item.setTimestampMs(parsed.timestamp * 1000L); + item.setMsgType(Short.toUnsignedInt(parsed.type)); + item.setMsgSubType(Short.toUnsignedInt(parsed.subType)); + item.setMsgVersion(Short.toUnsignedInt(parsed.version)); + if (parsed.body instanceof BodyHasTarget target) { + item.setToLogin(target.toLogin()); + item.setToForkNumber(target.toForkNumber()); + item.setToBlockNumber(target.toBlockGlobalNumber()); + item.setToBlockHash(hex(target.toBlockHashBytes())); + } + if (includeBytes) item.setBlockBytesB64(Base64Ws.encode(row.getBlockBytes())); + items.add(item); + } + + Net_GetMyBlockchain_Response resp = new Net_GetMyBlockchain_Response(); + resp.setOp(req.getOp()); + resp.setRequestId(req.getRequestId()); + resp.setStatus(WireCodes.Status.OK); + resp.setLogin(login); + resp.setBlockchainName(bch); + resp.setTipBlockNumber(tip); + resp.setTipBlockHash(tipHash); + resp.setBlocks(items); + int lowest = rows.isEmpty() ? -1 : rows.get(rows.size() - 1).getBlockNumber(); + resp.setNextBeforeBlock(lowest > 0 ? lowest - 1 : null); + return resp; + } catch (Exception e) { + return NetExceptionResponseFactory.error(req, 500, "GET_MY_BLOCKCHAIN_FAILED", "Не удалось прочитать блокчейн пользователя"); + } + } + + private static String hex(byte[] bytes) { + if (bytes == null) return null; + StringBuilder sb = new StringBuilder(bytes.length * 2); + for (byte b : bytes) sb.append(String.format("%02x", b & 0xff)); + return sb.toString(); + } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/entyties/Net_GetMyBlockchain_Request.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/entyties/Net_GetMyBlockchain_Request.java new file mode 100644 index 00000000..c2333237 --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/entyties/Net_GetMyBlockchain_Request.java @@ -0,0 +1,20 @@ +package server.logic.ws_protocol.JSON.handlers.blockchain.entyties; + +import server.logic.ws_protocol.JSON.entyties.Net_Request; + +/** Paginated read of the authenticated user's current materialized blockchain. */ +public final class Net_GetMyBlockchain_Request extends Net_Request { + /** Inclusive highest block number to return. Null/<0 means current tip. */ + private Integer beforeBlock; + /** 1..100, default 50. */ + private Integer limit; + /** Include complete serialized ANS-104 DataItem for rotation/UI inspection. */ + private Boolean includeBlockBytes; + + public Integer getBeforeBlock() { return beforeBlock; } + public void setBeforeBlock(Integer beforeBlock) { this.beforeBlock = beforeBlock; } + public Integer getLimit() { return limit; } + public void setLimit(Integer limit) { this.limit = limit; } + public Boolean getIncludeBlockBytes() { return includeBlockBytes; } + public void setIncludeBlockBytes(Boolean includeBlockBytes) { this.includeBlockBytes = includeBlockBytes; } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/entyties/Net_GetMyBlockchain_Response.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/entyties/Net_GetMyBlockchain_Response.java new file mode 100644 index 00000000..2b9c347b --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/entyties/Net_GetMyBlockchain_Response.java @@ -0,0 +1,67 @@ +package server.logic.ws_protocol.JSON.handlers.blockchain.entyties; + +import server.logic.ws_protocol.JSON.entyties.Net_Response; +import java.util.ArrayList; +import java.util.List; + +public final class Net_GetMyBlockchain_Response extends Net_Response { + private String login; + private String blockchainName; + private int tipBlockNumber; + private String tipBlockHash; + private Integer nextBeforeBlock; + private List blocks = new ArrayList<>(); + + public String getLogin() { return login; } + public void setLogin(String login) { this.login = login; } + public String getBlockchainName() { return blockchainName; } + public void setBlockchainName(String blockchainName) { this.blockchainName = blockchainName; } + public int getTipBlockNumber() { return tipBlockNumber; } + public void setTipBlockNumber(int tipBlockNumber) { this.tipBlockNumber = tipBlockNumber; } + public String getTipBlockHash() { return tipBlockHash; } + public void setTipBlockHash(String tipBlockHash) { this.tipBlockHash = tipBlockHash; } + public Integer getNextBeforeBlock() { return nextBeforeBlock; } + public void setNextBeforeBlock(Integer nextBeforeBlock) { this.nextBeforeBlock = nextBeforeBlock; } + public List getBlocks() { return blocks; } + public void setBlocks(List blocks) { this.blocks = blocks; } + + public static final class BlockItem { + private int blockNumber; + private String blockHash; + private String prevBlockHash; + private long timestampMs; + private int msgType; + private int msgSubType; + private int msgVersion; + private String toLogin; + private Integer toForkNumber; + private Integer toBlockNumber; + private String toBlockHash; + private String blockBytesB64; + + public int getBlockNumber() { return blockNumber; } + public void setBlockNumber(int blockNumber) { this.blockNumber = blockNumber; } + public String getBlockHash() { return blockHash; } + public void setBlockHash(String blockHash) { this.blockHash = blockHash; } + public String getPrevBlockHash() { return prevBlockHash; } + public void setPrevBlockHash(String prevBlockHash) { this.prevBlockHash = prevBlockHash; } + public long getTimestampMs() { return timestampMs; } + public void setTimestampMs(long timestampMs) { this.timestampMs = timestampMs; } + public int getMsgType() { return msgType; } + public void setMsgType(int msgType) { this.msgType = msgType; } + public int getMsgSubType() { return msgSubType; } + public void setMsgSubType(int msgSubType) { this.msgSubType = msgSubType; } + public int getMsgVersion() { return msgVersion; } + public void setMsgVersion(int msgVersion) { this.msgVersion = msgVersion; } + public String getToLogin() { return toLogin; } + public void setToLogin(String toLogin) { this.toLogin = toLogin; } + public Integer getToForkNumber() { return toForkNumber; } + public void setToForkNumber(Integer toForkNumber) { this.toForkNumber = toForkNumber; } + public Integer getToBlockNumber() { return toBlockNumber; } + public void setToBlockNumber(Integer toBlockNumber) { this.toBlockNumber = toBlockNumber; } + public String getToBlockHash() { return toBlockHash; } + public void setToBlockHash(String toBlockHash) { this.toBlockHash = toBlockHash; } + public String getBlockBytesB64() { return blockBytesB64; } + public void setBlockBytesB64(String blockBytesB64) { this.blockBytesB64 = blockBytesB64; } + } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/ChannelMetaTextParser.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/ChannelMetaTextParser.java index 57bd4ebb..1c192c53 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/ChannelMetaTextParser.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/ChannelMetaTextParser.java @@ -72,7 +72,7 @@ public final class ChannelMetaTextParser { String ar = String.valueOf(fields.getOrDefault("ar", "")).trim(); String sha256 = String.valueOf(fields.getOrDefault("sha256", "")).trim().toLowerCase(); String sizeRaw = String.valueOf(fields.containsKey("sz") ? fields.get("sz") : fields.getOrDefault("size", "")).trim(); - if (!ar.matches("^[A-Za-z0-9_-]{43}$")) throw new IllegalArgumentException("bad_channel_meta_avatar_ar"); + if (!ar.isEmpty() && !ar.matches("^[A-Za-z0-9_-]{43}$")) throw new IllegalArgumentException("bad_channel_meta_avatar_ar"); if (!sha256.matches("^[0-9a-f]{64}$")) throw new IllegalArgumentException("bad_channel_meta_avatar_sha256"); long size; try { diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/ChannelNamesStateBootstrapper.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/ChannelNamesStateBootstrapper.java index 9a02cf29..4da1a6d1 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/ChannelNamesStateBootstrapper.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/ChannelNamesStateBootstrapper.java @@ -17,6 +17,7 @@ import java.sql.ResultSet; import java.util.ArrayList; import java.util.LinkedHashMap; import java.util.List; +import java.util.Locale; import java.util.Map; public final class ChannelNamesStateBootstrapper { @@ -48,7 +49,15 @@ public final class ChannelNamesStateBootstrapper { SELECT login, bch_name, block_number, block_hash, block_bytes FROM blocks WHERE msg_type = ? AND msg_sub_type = ? - ORDER BY bch_name, block_number + AND fork_number=shine_canonical_fork( + login, + (SELECT substring(blockchain_name from '([0-9]{3})$')::INTEGER + FROM solana_user_pda_current + WHERE LOWER(login)=LOWER(blocks.login) + LIMIT 1), + block_number + ) + ORDER BY LOWER(login), block_number """; try (Connection c = DbController.getInstance().getConnection()) { @@ -107,7 +116,7 @@ public final class ChannelNamesStateBootstrapper { } String identity = ownerBch + "#" + blockNumber; - String ownerTypeSlug = ownerBch + "|" + channelTypeCode + "|" + slug; + String ownerTypeSlug = ownerLogin.toLowerCase(Locale.ROOT) + "|" + channelTypeCode + "|" + slug; String existing = slugToIdentity.putIfAbsent(ownerTypeSlug, identity); if (existing != null && !existing.equals(identity)) { conflicts.add("owner/type/slug=\"" + ownerTypeSlug + "\" conflicts: " + existing + " vs " + identity); @@ -138,6 +147,7 @@ public final class ChannelNamesStateBootstrapper { dao.insertAll(c, entries); applyMetaUpdates(c, dao, entries, skipped); + applyDeletionStates(c, dao, skipped); // v18: counters are a projection, so rebuild them from current state after a full channel-name bootstrap. try (PreparedStatement ps = c.prepareStatement("SELECT shine_refresh_user_stats(login) FROM solana_user_pda_current")) { ps.execute(); @@ -182,26 +192,76 @@ public final class ChannelNamesStateBootstrapper { } } + private static void applyDeletionStates(Connection c, ChannelNameStateDAO dao, List skipped) throws Exception { + String sql = """ + SELECT bch_name, block_number, block_bytes, msg_sub_type + FROM blocks + WHERE msg_type = ? AND msg_sub_type IN (?, ?, ?, ?, ?, ?, ?) + AND fork_number=shine_canonical_fork( + login, + (SELECT substring(blockchain_name from '([0-9]{3})$')::INTEGER + FROM solana_user_pda_current + WHERE LOWER(login)=LOWER(blocks.login) + LIMIT 1), + block_number + ) + ORDER BY LOWER(login), block_number + """; + try (PreparedStatement ps = c.prepareStatement(sql)) { + ps.setInt(1, MSG_TYPE_TEXT); + ps.setInt(2, MsgSubType.TEXT_CHANNEL_DELETE); + ps.setInt(3, MsgSubType.TEXT_POST); + ps.setInt(4, MsgSubType.TEXT_REPOST); + ps.setInt(5, MsgSubType.TEXT_ENTRYPOINT); + ps.setInt(6, MsgSubType.TEXT_EXERCISE); + ps.setInt(7, MsgSubType.TEXT_SERVICE); + ps.setInt(8, MsgSubType.TEXT_COURSE); + try (ResultSet rs = ps.executeQuery()) { + while (rs.next()) { + String ownerBch = rs.getString("bch_name"); + int blockNumber = rs.getInt("block_number"); + try { + BchBlockEntry parsed = new BchBlockEntry(rs.getBytes("block_bytes")); + if (!(parsed.body instanceof TextLineBody body) || body.lineCode() <= 0) continue; + boolean deleted = rs.getInt("msg_sub_type") == (MsgSubType.TEXT_CHANNEL_DELETE & 0xFFFF); + dao.updateDeletedState(c, ownerBch, body.lineCode(), deleted, deleted ? parsed.timestamp * 1000L : 0L, deleted ? blockNumber : null); + } catch (Exception e) { + skipped.add(ownerBch + "#" + blockNumber + " (invalid_channel_state_event)"); + } + } + } + } + } + private static void applyMetaUpdates(Connection c, ChannelNameStateDAO dao, List entries, List skipped) throws Exception { Map fallbackTitles = new LinkedHashMap<>(); for (ChannelNameStateEntry entry : entries) { - fallbackTitles.put(entry.getOwnerBlockchainName() + "#" + entry.getChannelRootBlockNumber(), entry.getSlug()); + fallbackTitles.put(entry.getOwnerLogin().toLowerCase() + "#" + entry.getChannelRootBlockNumber(), entry.getSlug()); } String sql = """ - SELECT bch_name, block_number, block_bytes + SELECT login, bch_name, block_number, block_bytes FROM blocks WHERE msg_type = ? AND msg_sub_type = ? - ORDER BY bch_name, block_number + AND fork_number=shine_canonical_fork( + login, + (SELECT substring(blockchain_name from '([0-9]{3})$')::INTEGER + FROM solana_user_pda_current + WHERE LOWER(login)=LOWER(blocks.login) + LIMIT 1), + block_number + ) + ORDER BY LOWER(login), block_number """; try (PreparedStatement ps = c.prepareStatement(sql)) { ps.setInt(1, MSG_TYPE_TEXT); ps.setInt(2, MsgSubType.TEXT_CHANNEL_META); try (ResultSet rs = ps.executeQuery()) { while (rs.next()) { + String ownerLogin = rs.getString("login"); String ownerBch = rs.getString("bch_name"); int blockNumber = rs.getInt("block_number"); byte[] blockBytes = rs.getBytes("block_bytes"); @@ -209,11 +269,12 @@ public final class ChannelNamesStateBootstrapper { BchBlockEntry parsed = new BchBlockEntry(blockBytes); if (!(parsed.body instanceof TextLineBody metaBody)) continue; int lineCode = metaBody.lineCode(); - String fallbackTitle = fallbackTitles.get(ownerBch + "#" + lineCode); + String fallbackTitle = fallbackTitles.get(ownerLogin.toLowerCase() + "#" + lineCode); if (fallbackTitle == null) continue; ChannelMetaTextParser.Parsed parsedMeta = ChannelMetaTextParser.parseStrict(metaBody.message, fallbackTitle); ChannelNameStateEntry update = new ChannelNameStateEntry(); + update.setOwnerLogin(ownerLogin); update.setOwnerBlockchainName(ownerBch); update.setChannelRootBlockNumber(lineCode); update.setDisplayName(parsedMeta.title()); diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/ChannelsReadSupport.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/ChannelsReadSupport.java index 762d8fba..0cb6637c 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/ChannelsReadSupport.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/ChannelsReadSupport.java @@ -3,7 +3,6 @@ package server.logic.ws_protocol.JSON.handlers.channels; import blockchain.BchBlockEntry; import blockchain.body.BodyRecord; import blockchain.body.CreateChannelBody; -import blockchain.body.TextBody; import blockchain.body.TextLineBody; import blockchain.body.TextReplyBody; import shine.db.channels.ChannelNameRules; @@ -54,13 +53,13 @@ final class ChannelsReadSupport { String stateSql = """ SELECT slug, display_name, channel_description, channel_type_code, channel_type_version, - ava_ar, ava_sha256, ava_size, meta_updated_at_ms + created_at_ms, ava_ar, ava_sha256, ava_size, meta_updated_at_ms, is_deleted, deleted_at_ms, deleted_block_number FROM channel_names_state - WHERE owner_bch_name = ? AND channel_root_block_number = ? + WHERE LOWER(owner_login)=LOWER(?) AND channel_root_block_number = ? LIMIT 1 """; try (PreparedStatement ps = c.prepareStatement(stateSql)) { - ps.setString(1, ownerBch); + ps.setString(1, loginFromChainName(ownerBch)); ps.setInt(2, rootNumber); try (ResultSet rs = ps.executeQuery()) { if (rs.next()) { @@ -69,10 +68,14 @@ final class ChannelsReadSupport { meta.channelDescription = String.valueOf(rs.getString("channel_description") == null ? "" : rs.getString("channel_description")); meta.channelTypeCode = rs.getInt("channel_type_code"); meta.channelTypeVersion = rs.getInt("channel_type_version"); + meta.createdAtMs = rs.getLong("created_at_ms"); meta.avaAr = String.valueOf(rs.getString("ava_ar") == null ? "" : rs.getString("ava_ar")); meta.avaSha256 = String.valueOf(rs.getString("ava_sha256") == null ? "" : rs.getString("ava_sha256")); meta.avaSize = rs.getLong("ava_size"); meta.metaUpdatedAtMs = rs.getLong("meta_updated_at_ms"); + meta.deleted = rs.getBoolean("is_deleted"); + meta.deletedAtMs = rs.getLong("deleted_at_ms"); + meta.deletedBlockNumber = (Integer) rs.getObject("deleted_block_number"); return meta; } } @@ -80,10 +83,17 @@ final class ChannelsReadSupport { // fallback ниже для окружений до миграции. } - String sql = "SELECT block_bytes FROM blocks WHERE bch_name=? AND block_number=? LIMIT 1"; + String sql = """ + SELECT block_bytes FROM blocks + WHERE LOWER(login)=LOWER(?) AND block_number=? + AND fork_number=shine_canonical_fork(login,(SELECT substring(blockchain_name from '([0-9]{3})$')::INTEGER FROM solana_user_pda_current WHERE LOWER(login)=LOWER(?) LIMIT 1),block_number) + LIMIT 1 + """; try (PreparedStatement ps = c.prepareStatement(sql)) { - ps.setString(1, ownerBch); + String ownerLogin=loginFromChainName(ownerBch); + ps.setString(1, ownerLogin); ps.setInt(2, rootNumber); + ps.setString(3, ownerLogin); try (ResultSet rs = ps.executeQuery()) { if (!rs.next()) { meta.channelName = null; @@ -107,6 +117,7 @@ final class ChannelsReadSupport { meta.avaAr = parsedMeta.avaAr(); meta.avaSha256 = parsedMeta.avaSha256(); meta.avaSize = parsedMeta.avaSize(); + meta.createdAtMs = e.timestamp * 1000L; meta.metaUpdatedAtMs = e.timestamp * 1000L; } } else { @@ -127,20 +138,14 @@ final class ChannelsReadSupport { } static int countPosts(Connection c, String ownerBch, int lineCode) throws SQLException { - String sql = "SELECT COUNT(*) AS cnt FROM blocks WHERE bch_name=? AND msg_type=? AND msg_sub_type IN (?, ?, ?, ?, ?, ?) AND line_code=?"; + String sql = """ + SELECT COUNT(*) AS cnt FROM blocks + WHERE LOWER(login)=LOWER(?) AND msg_type=? AND msg_sub_type IN (?, ?, ?, ?, ?, ?) AND line_code=? + AND fork_number=shine_canonical_fork(login,(SELECT substring(blockchain_name from '([0-9]{3})$')::INTEGER FROM solana_user_pda_current WHERE LOWER(login)=LOWER(?) LIMIT 1),block_number) + """; try (PreparedStatement ps = c.prepareStatement(sql)) { - ps.setString(1, ownerBch); - ps.setInt(2, MSG_TYPE_TEXT); - ps.setInt(3, MsgSubType.TEXT_POST); - ps.setInt(4, MsgSubType.TEXT_REPOST); - ps.setInt(5, MsgSubType.TEXT_ENTRYPOINT); - ps.setInt(6, MsgSubType.TEXT_EXERCISE); - ps.setInt(7, MsgSubType.TEXT_SERVICE); - ps.setInt(8, MsgSubType.TEXT_COURSE); - ps.setInt(9, lineCode); - try (ResultSet rs = ps.executeQuery()) { - return rs.next() ? rs.getInt("cnt") : 0; - } + String login=loginFromChainName(ownerBch); ps.setString(1,login); ps.setInt(2,MSG_TYPE_TEXT); ps.setInt(3,MsgSubType.TEXT_POST); ps.setInt(4,MsgSubType.TEXT_REPOST); ps.setInt(5,MsgSubType.TEXT_ENTRYPOINT); ps.setInt(6,MsgSubType.TEXT_EXERCISE); ps.setInt(7,MsgSubType.TEXT_SERVICE); ps.setInt(8,MsgSubType.TEXT_COURSE); ps.setInt(9,lineCode); ps.setString(10,login); + try(ResultSet rs=ps.executeQuery()){return rs.next()?rs.getInt("cnt"):0;} } } @@ -153,52 +158,32 @@ final class ChannelsReadSupport { } static PostBlock loadLastPost(Connection c, String ownerBch, int lineCode) throws SQLException { - String sql = """ - SELECT login,bch_name,block_number,block_hash,block_bytes,this_line_number - FROM blocks - WHERE bch_name=? AND msg_type=? AND msg_sub_type IN (?, ?, ?, ?, ?, ?) AND line_code=? - ORDER BY block_number DESC - LIMIT 1 + String sql=""" + SELECT login,bch_name,block_number,block_hash,block_bytes,this_line_number FROM blocks + WHERE LOWER(login)=LOWER(?) AND msg_type=? AND msg_sub_type IN (?, ?, ?, ?, ?, ?) AND line_code=? + AND fork_number=shine_canonical_fork(login,(SELECT substring(blockchain_name from '([0-9]{3})$')::INTEGER FROM solana_user_pda_current WHERE LOWER(login)=LOWER(?) LIMIT 1),block_number) + ORDER BY block_number DESC LIMIT 1 """; - try (PreparedStatement ps = c.prepareStatement(sql)) { - ps.setString(1, ownerBch); - ps.setInt(2, MSG_TYPE_TEXT); - ps.setInt(3, MsgSubType.TEXT_POST); - ps.setInt(4, MsgSubType.TEXT_REPOST); - ps.setInt(5, MsgSubType.TEXT_ENTRYPOINT); - ps.setInt(6, MsgSubType.TEXT_EXERCISE); - ps.setInt(7, MsgSubType.TEXT_SERVICE); - ps.setInt(8, MsgSubType.TEXT_COURSE); - ps.setInt(9, lineCode); - try (ResultSet rs = ps.executeQuery()) { - if (!rs.next()) return null; - PostBlock pb = new PostBlock(); - pb.login = rs.getString("login"); - pb.bchName = rs.getString("bch_name"); - pb.blockNumber = rs.getInt("block_number"); - pb.blockHash = rs.getBytes("block_hash"); - pb.blockBytes = rs.getBytes("block_bytes"); - return pb; - } - } + try(PreparedStatement ps=c.prepareStatement(sql)){String login=loginFromChainName(ownerBch);ps.setString(1,login);ps.setInt(2,MSG_TYPE_TEXT);ps.setInt(3,MsgSubType.TEXT_POST);ps.setInt(4,MsgSubType.TEXT_REPOST);ps.setInt(5,MsgSubType.TEXT_ENTRYPOINT);ps.setInt(6,MsgSubType.TEXT_EXERCISE);ps.setInt(7,MsgSubType.TEXT_SERVICE);ps.setInt(8,MsgSubType.TEXT_COURSE);ps.setInt(9,lineCode);ps.setString(10,login);try(ResultSet rs=ps.executeQuery()){if(!rs.next())return null;PostBlock pb=new PostBlock();pb.login=rs.getString("login");pb.bchName=rs.getString("bch_name");pb.blockNumber=rs.getInt("block_number");pb.blockHash=rs.getBytes("block_hash");pb.blockBytes=rs.getBytes("block_bytes");return pb;}} } static PostBlock loadLastVersion(Connection c, String ownerBch, int originalBlockNumber, byte[] originalHash) throws SQLException { String sql = """ SELECT login,bch_name,block_number,block_hash,block_bytes,this_line_number FROM blocks - WHERE bch_name=? AND msg_type=? AND msg_sub_type=? - AND to_bch_name=? AND to_block_number=? AND to_block_hash=? + WHERE LOWER(login)=LOWER(?) AND msg_type=? AND msg_sub_type=? + AND to_block_number=? AND to_block_hash=? + AND fork_number=shine_canonical_fork(login,(SELECT substring(blockchain_name from '([0-9]{3})$')::INTEGER FROM solana_user_pda_current WHERE LOWER(login)=LOWER(?) LIMIT 1),block_number) ORDER BY block_number DESC LIMIT 1 """; try (PreparedStatement ps = c.prepareStatement(sql)) { - ps.setString(1, ownerBch); + ps.setString(1, loginFromChainName(ownerBch)); ps.setInt(2, MSG_TYPE_TEXT); ps.setInt(3, MsgSubType.TEXT_EDIT_POST); - ps.setString(4, ownerBch); - ps.setInt(5, originalBlockNumber); - ps.setBytes(6, originalHash); + ps.setInt(4, originalBlockNumber); + ps.setBytes(5, originalHash); + ps.setString(6, loginFromChainName(ownerBch)); try (ResultSet rs = ps.executeQuery()) { if (!rs.next()) return null; PostBlock pb = new PostBlock(); @@ -225,8 +210,6 @@ final class ChannelsReadSupport { ti.text = trb.message; } else if (e.body instanceof blockchain.body.StatusActionBody sab) { ti.text = sab.message; - } else if (e.body instanceof TextBody tb) { - ti.text = tb.message; } return ti; } catch (Exception ex) { @@ -240,11 +223,12 @@ final class ChannelsReadSupport { String sql = """ SELECT login,bch_name,block_number,block_hash,block_bytes,to_bch_name,to_block_number,to_block_hash,msg_sub_type,this_line_number FROM blocks - WHERE bch_name=? AND msg_type=? AND msg_sub_type IN (?, ?, ?, ?, ?, ?) AND line_code=? + WHERE LOWER(login)=LOWER(?) AND msg_type=? AND msg_sub_type IN (?, ?, ?, ?, ?, ?) AND line_code=? + AND fork_number=shine_canonical_fork(login,(SELECT substring(blockchain_name from '([0-9]{3})$')::INTEGER FROM solana_user_pda_current WHERE LOWER(login)=LOWER(?) LIMIT 1),block_number) ORDER BY block_number """ + order + (bounded ? " LIMIT ?" : ""); try (PreparedStatement ps = c.prepareStatement(sql)) { - ps.setString(1, ownerBch); + ps.setString(1, loginFromChainName(ownerBch)); ps.setInt(2, MSG_TYPE_TEXT); ps.setInt(3, MsgSubType.TEXT_POST); ps.setInt(4, MsgSubType.TEXT_REPOST); @@ -253,7 +237,8 @@ final class ChannelsReadSupport { ps.setInt(7, MsgSubType.TEXT_SERVICE); ps.setInt(8, MsgSubType.TEXT_COURSE); ps.setInt(9, lineCode); - if (bounded) ps.setInt(10, limit); + ps.setString(10, loginFromChainName(ownerBch)); + if (bounded) ps.setInt(11, limit); try (ResultSet rs = ps.executeQuery()) { List out = new ArrayList<>(); while (rs.next()) { @@ -288,18 +273,18 @@ final class ChannelsReadSupport { String sql = """ SELECT login,bch_name,block_number,block_hash,block_bytes FROM blocks - WHERE bch_name=? AND msg_type=? AND msg_sub_type=? + WHERE LOWER(login)=LOWER(?) AND msg_type=? AND msg_sub_type=? AND to_block_number=? AND to_block_hash=? - AND (to_bch_name=? OR to_bch_name IS NULL OR to_bch_name='') + AND fork_number=shine_canonical_fork(login,(SELECT substring(blockchain_name from '([0-9]{3})$')::INTEGER FROM solana_user_pda_current WHERE LOWER(login)=LOWER(?) LIMIT 1),block_number) ORDER BY block_number ASC """; try (PreparedStatement ps = c.prepareStatement(sql)) { - ps.setString(1, ownerBch); + ps.setString(1, loginFromChainName(ownerBch)); ps.setInt(2, MSG_TYPE_TEXT); ps.setInt(3, MsgSubType.TEXT_EDIT_POST); ps.setInt(4, originalBlock); ps.setBytes(5, originalHash); - ps.setString(6, ownerBch); + ps.setString(6, loginFromChainName(ownerBch)); try (ResultSet rs = ps.executeQuery()) { List out = new ArrayList<>(); while (rs.next()) { @@ -317,13 +302,13 @@ final class ChannelsReadSupport { } static int[] loadStats(Connection c, String bch, int blockNumber, byte[] blockHash) throws SQLException { - String sql = "SELECT likes_count,primary_likes_count,shining_likes_count,replies_count FROM message_stats WHERE to_bch_name=? AND to_block_number=? AND to_block_hash=? LIMIT 1"; + String sql = "SELECT likes_count,primary_likes_count,shining_likes_count,replies_count FROM message_stats WHERE LOWER(to_login)=LOWER(?) AND to_block_number=? AND to_block_hash=? LIMIT 1"; int likesCount = 0; int primaryLikesCount = 0; int shiningLikesCount = 0; int repliesCount = 0; try (PreparedStatement ps = c.prepareStatement(sql)) { - ps.setString(1, bch); + ps.setString(1, loginFromChainName(bch)); ps.setInt(2, blockNumber); ps.setBytes(3, blockHash); try (ResultSet rs = ps.executeQuery()) { @@ -340,15 +325,16 @@ final class ChannelsReadSupport { FROM blocks WHERE msg_type = ? AND msg_sub_type = ? - AND to_bch_name = ? + AND LOWER(to_login) = LOWER(?) AND to_block_number = ? AND to_block_hash = ? + AND fork_number=shine_canonical_fork(login,(SELECT substring(blockchain_name from '([0-9]{3})$')::INTEGER FROM solana_user_pda_current WHERE LOWER(login)=LOWER(blocks.login) LIMIT 1),block_number) """; int ratingsCount = 0; try (PreparedStatement ps = c.prepareStatement(ratingsSql)) { ps.setInt(1, MSG_TYPE_TEXT); ps.setInt(2, MsgSubType.TEXT_RATING); - ps.setString(3, bch); + ps.setString(3, loginFromChainName(bch)); ps.setInt(4, blockNumber); ps.setBytes(5, blockHash); try (ResultSet rs = ps.executeQuery()) { @@ -369,11 +355,11 @@ final class ChannelsReadSupport { String stateSql = """ SELECT channel_description FROM channel_names_state - WHERE owner_bch_name = ? AND channel_root_block_number = ? + WHERE LOWER(owner_login)=LOWER(?) AND channel_root_block_number = ? LIMIT 1 """; try (PreparedStatement ps = c.prepareStatement(stateSql)) { - ps.setString(1, ownerBch); + ps.setString(1, loginFromChainName(ownerBch)); ps.setInt(2, rootNumber); try (ResultSet rs = ps.executeQuery()) { if (rs.next()) { @@ -386,10 +372,17 @@ final class ChannelsReadSupport { } // Fallback: parse root block directly. - String sql = "SELECT block_bytes FROM blocks WHERE bch_name=? AND block_number=? LIMIT 1"; + String sql = """ + SELECT block_bytes FROM blocks + WHERE LOWER(login)=LOWER(?) AND block_number=? + AND fork_number=shine_canonical_fork(login,(SELECT substring(blockchain_name from '([0-9]{3})$')::INTEGER FROM solana_user_pda_current WHERE LOWER(login)=LOWER(?) LIMIT 1),block_number) + LIMIT 1 + """; try (PreparedStatement ps = c.prepareStatement(sql)) { - ps.setString(1, ownerBch); + String ownerLogin=loginFromChainName(ownerBch); + ps.setString(1, ownerLogin); ps.setInt(2, rootNumber); + ps.setString(3, ownerLogin); try (ResultSet rs = ps.executeQuery()) { if (!rs.next()) return ""; byte[] bytes = rs.getBytes("block_bytes"); @@ -411,11 +404,11 @@ final class ChannelsReadSupport { String stateSql = """ SELECT channel_type_code FROM channel_names_state - WHERE owner_bch_name = ? AND channel_root_block_number = ? + WHERE LOWER(owner_login)=LOWER(?) AND channel_root_block_number = ? LIMIT 1 """; try (PreparedStatement ps = c.prepareStatement(stateSql)) { - ps.setString(1, ownerBch); + ps.setString(1, loginFromChainName(ownerBch)); ps.setInt(2, rootNumber); try (ResultSet rs = ps.executeQuery()) { if (rs.next()) return rs.getInt("channel_type_code"); @@ -434,11 +427,11 @@ final class ChannelsReadSupport { String stateSql = """ SELECT channel_type_version FROM channel_names_state - WHERE owner_bch_name = ? AND channel_root_block_number = ? + WHERE LOWER(owner_login)=LOWER(?) AND channel_root_block_number = ? LIMIT 1 """; try (PreparedStatement ps = c.prepareStatement(stateSql)) { - ps.setString(1, ownerBch); + ps.setString(1, loginFromChainName(ownerBch)); ps.setInt(2, rootNumber); try (ResultSet rs = ps.executeQuery()) { if (rs.next()) return rs.getInt("channel_type_version"); @@ -458,14 +451,17 @@ final class ChannelsReadSupport { String rootSql = """ SELECT login,bch_name,block_number,block_hash,block_bytes,this_line_number FROM blocks - WHERE bch_name=? AND msg_type=? AND msg_sub_type=? AND block_number=? + WHERE LOWER(login)=LOWER(?) AND msg_type=? AND msg_sub_type=? AND block_number=? + AND fork_number=shine_canonical_fork(login,(SELECT substring(blockchain_name from '([0-9]{3})$')::INTEGER FROM solana_user_pda_current WHERE LOWER(login)=LOWER(?) LIMIT 1),block_number) LIMIT 1 """; try (PreparedStatement ps = c.prepareStatement(rootSql)) { - ps.setString(1, ownerBch); + String ownerLogin=loginFromChainName(ownerBch); + ps.setString(1, ownerLogin); ps.setInt(2, MSG_TYPE_TECH); ps.setInt(3, 1); ps.setInt(4, lineCode); + ps.setString(5, ownerLogin); try (ResultSet rs = ps.executeQuery()) { if (rs.next()) { MetaEvent event = new MetaEvent(); @@ -507,14 +503,16 @@ final class ChannelsReadSupport { String sql = """ SELECT login,bch_name,block_number,block_hash,block_bytes,this_line_number FROM blocks - WHERE bch_name=? AND msg_type=? AND msg_sub_type=? AND line_code=? + WHERE LOWER(login)=LOWER(?) AND msg_type=? AND msg_sub_type=? AND line_code=? + AND fork_number=shine_canonical_fork(login,(SELECT substring(blockchain_name from '([0-9]{3})$')::INTEGER FROM solana_user_pda_current WHERE LOWER(login)=LOWER(?) LIMIT 1),block_number) ORDER BY block_number ASC """; try (PreparedStatement ps = c.prepareStatement(sql)) { - ps.setString(1, ownerBch); + ps.setString(1, loginFromChainName(ownerBch)); ps.setInt(2, MSG_TYPE_TEXT); ps.setInt(3, MsgSubType.TEXT_CHANNEL_META); ps.setInt(4, lineCode); + ps.setString(5, loginFromChainName(ownerBch)); try (ResultSet rs = ps.executeQuery()) { while (rs.next()) { byte[] bytes = rs.getBytes("block_bytes"); @@ -541,6 +539,36 @@ final class ChannelsReadSupport { } } } + + String deleteSql = """ + SELECT login,bch_name,block_number,block_hash,block_bytes,this_line_number + FROM blocks + WHERE LOWER(login)=LOWER(?) AND msg_type=? AND msg_sub_type=? AND line_code=? + AND fork_number=shine_canonical_fork(login,(SELECT substring(blockchain_name from '([0-9]{3})$')::INTEGER FROM solana_user_pda_current WHERE LOWER(login)=LOWER(?) LIMIT 1),block_number) + ORDER BY block_number ASC + """; + try (PreparedStatement ps = c.prepareStatement(deleteSql)) { + ps.setString(1, loginFromChainName(ownerBch)); + ps.setInt(2, MSG_TYPE_TEXT); + ps.setInt(3, MsgSubType.TEXT_CHANNEL_DELETE); + ps.setInt(4, lineCode); + ps.setString(5, loginFromChainName(ownerBch)); + try (ResultSet rs = ps.executeQuery()) { + while (rs.next()) { + MetaEvent event = new MetaEvent(); + event.kind = "deleted"; + event.login = rs.getString("login"); + event.bchName = rs.getString("bch_name"); + event.blockNumber = rs.getInt("block_number"); + event.blockHash = rs.getBytes("block_hash"); + event.lineStep = (Integer) rs.getObject("this_line_number"); + try { event.createdAtMs = new BchBlockEntry(rs.getBytes("block_bytes")).timestamp * 1000L; } + catch (Exception ignored) { event.createdAtMs = 0L; } + out.add(event); + } + } + } + out.sort(Comparator.comparingLong((MetaEvent e) -> e.createdAtMs).thenComparingInt(e -> e.blockNumber)); return out; } @@ -552,9 +580,8 @@ final class ChannelsReadSupport { String partnerBchSql = """ SELECT blockchain_name - FROM blockchain_state + FROM solana_user_pda_current WHERE LOWER(login) = LOWER(?) - ORDER BY blockchain_name LIMIT 1 """; @@ -577,14 +604,14 @@ final class ChannelsReadSupport { String rootSql = """ SELECT channel_root_block_number FROM channel_names_state - WHERE owner_bch_name = ? + WHERE LOWER(owner_login)=LOWER(?) AND channel_type_code = ? AND slug = ? ORDER BY channel_root_block_number DESC LIMIT 1 """; try (PreparedStatement ps = c.prepareStatement(rootSql)) { - ps.setString(1, partnerBch); + ps.setString(1, canonicalPartner); ps.setInt(2, CreateChannelBody.CHANNEL_TYPE_PERSONAL & 0xFFFF); ps.setString(3, ownerSlug); try (ResultSet rs = ps.executeQuery()) { @@ -601,26 +628,25 @@ final class ChannelsReadSupport { if (login == null || login.isBlank() || toBch == null || toBch.isBlank() || toBlockHash == null || toBlockHash.length != 32) { return false; } + String targetLogin = loginFromChainName(toBch); + if (targetLogin == null || targetLogin.isBlank()) return false; String sql = """ - SELECT msg_sub_type - FROM blocks - WHERE LOWER(login) = LOWER(?) - AND msg_type = ? - AND to_bch_name = ? + SELECT last_sub_type + FROM reactions_state + WHERE LOWER(from_login) = LOWER(?) + AND reaction_type = 1 + AND LOWER(to_login) = LOWER(?) AND to_block_number = ? AND to_block_hash = ? - ORDER BY block_number DESC LIMIT 1 """; try (PreparedStatement ps = c.prepareStatement(sql)) { ps.setString(1, login); - ps.setInt(2, MSG_TYPE_REACTION); - ps.setString(3, toBch); - ps.setInt(4, toBlockNumber); - ps.setBytes(5, toBlockHash); + ps.setString(2, targetLogin); + ps.setInt(3, toBlockNumber); + ps.setBytes(4, toBlockHash); try (ResultSet rs = ps.executeQuery()) { - if (!rs.next()) return false; - return rs.getInt("msg_sub_type") == MsgSubType.REACTION_LIKE; + return rs.next() && rs.getInt("last_sub_type") == MsgSubType.REACTION_LIKE; } } } @@ -689,7 +715,11 @@ final class ChannelsReadSupport { String avaAr = ""; String avaSha256 = ""; long avaSize = 0L; + long createdAtMs = 0L; long metaUpdatedAtMs = 0L; + boolean deleted = false; + long deletedAtMs = 0L; + Integer deletedBlockNumber; } static final class MetaEvent { @@ -711,4 +741,8 @@ final class ChannelsReadSupport { String ownerBlockchainName; int channelRootBlockNumber; } + static String loginFromChainName(String bch) { + if (bch == null) return null; int d=bch.lastIndexOf('-'); return d>0?bch.substring(0,d):bch; + } + } diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetChannelMessages_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetChannelMessages_Handler.java index f3c6e71c..997dc1a9 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetChannelMessages_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetChannelMessages_Handler.java @@ -67,9 +67,13 @@ public class Net_GetChannelMessages_Handler implements JsonMessageHandler { channel.setAvaSha256(meta.avaSha256); channel.setAvaSize(meta.avaSize); channel.setMetaUpdatedAtMs(meta.metaUpdatedAtMs); + channel.setCreatedAtMs(meta.createdAtMs); channel.setChannelTypeCode(meta.channelTypeCode); channel.setChannelTypeVersion(meta.channelTypeVersion); channel.setSubscribersCount(loadSubscribersCount(c, ownerBch, lineCode, meta.channelTypeCode)); + channel.setDeleted(meta.deleted); + channel.setDeletedAtMs(meta.deletedAtMs); + channel.setDeletedBlockNumber(meta.deletedBlockNumber); Net_GetChannelMessages_Response.BlockRef rootRef = new Net_GetChannelMessages_Response.BlockRef(); rootRef.setBlockNumber(lineCode); rootRef.setBlockHash(req.getChannel().getChannelRootBlockHash()); @@ -195,12 +199,12 @@ public class Net_GetChannelMessages_Handler implements JsonMessageHandler { String sql = """ SELECT subscribers_count FROM channel_stats_state - WHERE owner_bch_name = ? + WHERE LOWER(owner_login)=LOWER(?) AND channel_root_block_number = ? LIMIT 1 """; try (PreparedStatement ps = c.prepareStatement(sql)) { - ps.setString(1, ownerBch); + ps.setString(1, BlockchainNameUtil.loginFromBlockchainName(ownerBch)); ps.setInt(2, rootNumber); try (ResultSet rs = ps.executeQuery()) { if (!rs.next()) return 0; diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetGroupDialog_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetGroupDialog_Handler.java index c9855c61..2c4a2884 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetGroupDialog_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetGroupDialog_Handler.java @@ -20,6 +20,8 @@ import java.util.ArrayList; import java.util.Comparator; import java.util.List; +/** @deprecated Chat200 is legacy/non-working/unused and is not maintained for segmented forks. */ +@Deprecated public class Net_GetGroupDialog_Handler implements JsonMessageHandler { private static final Logger log = LoggerFactory.getLogger(Net_GetGroupDialog_Handler.class); @@ -156,13 +158,14 @@ public class Net_GetGroupDialog_Handler implements JsonMessageHandler { String sql = """ SELECT login, bch_name, block_number, block_hash, block_bytes FROM blocks - WHERE bch_name = ? AND msg_type = 1 AND line_code = ? + WHERE LOWER(login)=LOWER(?) AND msg_type=1 AND line_code=? AND fork_number=shine_canonical_fork(login,(SELECT substring(blockchain_name from '([0-9]{3})$')::INTEGER FROM solana_user_pda_current WHERE LOWER(login)=LOWER(?) LIMIT 1),block_number) ORDER BY block_number ASC """; List out = new ArrayList<>(); try (PreparedStatement ps = c.prepareStatement(sql)) { - ps.setString(1, ownerBch); + ps.setString(1, ChannelsReadSupport.loginFromChainName(ownerBch)); ps.setInt(2, line); + ps.setString(3, ChannelsReadSupport.loginFromChainName(ownerBch)); try (ResultSet rs = ps.executeQuery()) { while (rs.next()) { MsgRow row = new MsgRow(); diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetMessageLikes_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetMessageLikes_Handler.java index 3cd3fa8d..3f5ffb28 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetMessageLikes_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetMessageLikes_Handler.java @@ -53,7 +53,7 @@ public class Net_GetMessageLikes_Handler implements JsonMessageHandler { LEFT JOIN user_profile_state ups ON LOWER(ups.login) = LOWER(rs.from_login) WHERE rs.reaction_type = 1 AND rs.last_sub_type = 1 - AND rs.to_bch_name = ? + AND LOWER(rs.to_login) = LOWER(?) AND rs.to_block_number = ? AND rs.to_block_hash = ? ORDER BY LOWER(rs.from_login) @@ -63,7 +63,7 @@ public class Net_GetMessageLikes_Handler implements JsonMessageHandler { List official = new ArrayList<>(); List others = new ArrayList<>(); try (PreparedStatement ps = c.prepareStatement(sql)) { - ps.setString(1, message.getBlockchainName().trim()); + ps.setString(1, loginFromChainName(message.getBlockchainName().trim())); ps.setInt(2, message.getBlockNumber()); ps.setBytes(3, blockHash); try (ResultSet rs = ps.executeQuery()) { @@ -98,4 +98,8 @@ public class Net_GetMessageLikes_Handler implements JsonMessageHandler { return NetExceptionResponseFactory.error(req, WireCodes.Status.INTERNAL_ERROR, "internal_error", "Внутренняя ошибка сервера"); } } + private static String loginFromChainName(String bch) { + if (bch == null) return null; int d=bch.lastIndexOf('-'); return d>0?bch.substring(0,d):bch; + } + } diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetMessageThread_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetMessageThread_Handler.java index 5405f803..723db4c0 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetMessageThread_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetMessageThread_Handler.java @@ -56,8 +56,17 @@ public class Net_GetMessageThread_Handler implements JsonMessageHandler { List ancestors = new ArrayList<>(); PostRow cur = focusRow; for (int i = 0; i < depthUp; i++) { - if (cur.toBlockNumber == null || cur.toBchName == null) break; - PostRow parent = findByNumber(c, cur.toBchName, cur.toBlockNumber); + if (cur.toBlockNumber == null) break; + PostRow parent; + if (cur.msgSubType == MsgSubType.TEXT_RATING + && cur.toLogin != null && !cur.toLogin.isBlank() + && cur.toBlockHash != null && cur.toBlockHash.length == 32) { + parent = findByLogicalTarget(c, cur.toLogin, cur.toBlockNumber, cur.toBlockHash); + } else { + // REPLY and other legacy thread links intentionally keep their existing physical-target behavior. + if (cur.toBchName == null) break; + parent = findByNumber(c, cur.toBchName, cur.toBlockNumber); + } if (parent == null) break; ancestors.add(0, toNode(c, parent, viewerLogin)); cur = parent; @@ -102,18 +111,28 @@ public class Net_GetMessageThread_Handler implements JsonMessageHandler { } private List findRepliesAndRatings(Connection c, String toBchName, int toBlockNumber, byte[] toBlockHash, int limit) throws Exception { + String targetLogin = ChannelsReadSupport.loginFromChainName(toBchName); String sql = """ - SELECT login,bch_name,block_number,block_hash,block_bytes,to_bch_name,to_block_number,to_block_hash,line_code,msg_sub_type,this_line_number + SELECT login,bch_name,block_number,block_hash,block_bytes,to_login,to_bch_name,to_block_number,to_block_hash,line_code,msg_sub_type,this_line_number FROM blocks - WHERE msg_type=1 AND msg_sub_type IN (?, ?) - AND to_bch_name=? AND to_block_number=? AND to_block_hash=? + WHERE msg_type=1 + AND to_block_number=? AND to_block_hash=? + AND ( + (msg_sub_type=? AND (LOWER(to_login)=LOWER(?) OR to_bch_name=?)) + OR (msg_sub_type=? AND LOWER(to_login)=LOWER(?)) + ) + AND fork_number=shine_canonical_fork(login,(SELECT substring(blockchain_name from '([0-9]{3})$')::INTEGER FROM solana_user_pda_current WHERE LOWER(login)=LOWER(blocks.login) LIMIT 1),block_number) """; try (PreparedStatement ps = c.prepareStatement(sql)) { - ps.setInt(1, MsgSubType.TEXT_REPLY); - ps.setInt(2, MsgSubType.TEXT_RATING); - ps.setString(3, toBchName); - ps.setInt(4, toBlockNumber); - ps.setBytes(5, toBlockHash); + ps.setInt(1, toBlockNumber); + ps.setBytes(2, toBlockHash); + // REPLY keeps its legacy physical-target lookup intentionally. + ps.setInt(3, MsgSubType.TEXT_REPLY); + ps.setString(4, targetLogin); + ps.setString(5, toBchName); + // RATING follows the Stage 2 logical target identity. + ps.setInt(6, MsgSubType.TEXT_RATING); + ps.setString(7, targetLogin); try (ResultSet rs = ps.executeQuery()) { List out = new ArrayList<>(); while (rs.next()) out.add(mapRow(rs)); @@ -129,16 +148,38 @@ public class Net_GetMessageThread_Handler implements JsonMessageHandler { } } - private PostRow findByNumber(Connection c, String bchName, int blockNumber) throws Exception { + private PostRow findByLogicalTarget(Connection c, String login, int blockNumber, byte[] blockHash) throws Exception { String sql = """ - SELECT login,bch_name,block_number,block_hash,block_bytes,to_bch_name,to_block_number,to_block_hash,line_code,msg_sub_type,this_line_number + SELECT login,bch_name,block_number,block_hash,block_bytes,to_login,to_bch_name,to_block_number,to_block_hash,line_code,msg_sub_type,this_line_number FROM blocks - WHERE bch_name=? AND block_number=? + WHERE LOWER(login)=LOWER(?) AND block_number=? AND block_hash=? + AND fork_number=shine_canonical_fork(login,(SELECT substring(blockchain_name from '([0-9]{3})$')::INTEGER FROM solana_user_pda_current WHERE LOWER(login)=LOWER(?) LIMIT 1),block_number) LIMIT 1 """; try (PreparedStatement ps = c.prepareStatement(sql)) { - ps.setString(1, bchName); + ps.setString(1, login); ps.setInt(2, blockNumber); + ps.setBytes(3, blockHash); + ps.setString(4, login); + try (ResultSet rs = ps.executeQuery()) { + return rs.next() ? mapRow(rs) : null; + } + } + } + + private PostRow findByNumber(Connection c, String bchName, int blockNumber) throws Exception { + String sql = """ + SELECT login,bch_name,block_number,block_hash,block_bytes,to_login,to_bch_name,to_block_number,to_block_hash,line_code,msg_sub_type,this_line_number + FROM blocks + WHERE LOWER(login)=LOWER(?) AND block_number=? + AND fork_number=shine_canonical_fork(login,(SELECT substring(blockchain_name from '([0-9]{3})$')::INTEGER FROM solana_user_pda_current WHERE LOWER(login)=LOWER(?) LIMIT 1),block_number) + LIMIT 1 + """; + try (PreparedStatement ps = c.prepareStatement(sql)) { + String login=ChannelsReadSupport.loginFromChainName(bchName); + ps.setString(1, login); + ps.setInt(2, blockNumber); + ps.setString(3, login); try (ResultSet rs = ps.executeQuery()) { return rs.next() ? mapRow(rs) : null; } @@ -147,15 +188,18 @@ public class Net_GetMessageThread_Handler implements JsonMessageHandler { private PostRow findByNumberAndHash(Connection c, String bchName, int blockNumber, byte[] blockHash) throws Exception { String sql = """ - SELECT login,bch_name,block_number,block_hash,block_bytes,to_bch_name,to_block_number,to_block_hash,line_code,msg_sub_type,this_line_number + SELECT login,bch_name,block_number,block_hash,block_bytes,to_login,to_bch_name,to_block_number,to_block_hash,line_code,msg_sub_type,this_line_number FROM blocks - WHERE bch_name=? AND block_number=? AND block_hash=? + WHERE LOWER(login)=LOWER(?) AND block_number=? AND block_hash=? + AND fork_number=shine_canonical_fork(login,(SELECT substring(blockchain_name from '([0-9]{3})$')::INTEGER FROM solana_user_pda_current WHERE LOWER(login)=LOWER(?) LIMIT 1),block_number) LIMIT 1 """; try (PreparedStatement ps = c.prepareStatement(sql)) { - ps.setString(1, bchName); + String login=ChannelsReadSupport.loginFromChainName(bchName); + ps.setString(1, login); ps.setInt(2, blockNumber); ps.setBytes(3, blockHash); + ps.setString(4, login); try (ResultSet rs = ps.executeQuery()) { return rs.next() ? mapRow(rs) : null; } @@ -179,6 +223,7 @@ public class Net_GetMessageThread_Handler implements JsonMessageHandler { row.blockNumber = rs.getInt("block_number"); row.blockHash = rs.getBytes("block_hash"); row.blockBytes = rs.getBytes("block_bytes"); + row.toLogin = rs.getString("to_login"); row.toBchName = rs.getString("to_bch_name"); row.toBlockNumber = (Integer) rs.getObject("to_block_number"); row.toBlockHash = rs.getBytes("to_block_hash"); @@ -262,19 +307,20 @@ public class Net_GetMessageThread_Handler implements JsonMessageHandler { private List findEdits(Connection c, String bch, int targetBlock, byte[] targetHash, int subType) throws Exception { String sql = """ - SELECT login,bch_name,block_number,block_hash,block_bytes,to_bch_name,to_block_number,to_block_hash,line_code,msg_sub_type,this_line_number + SELECT login,bch_name,block_number,block_hash,block_bytes,to_login,to_bch_name,to_block_number,to_block_hash,line_code,msg_sub_type,this_line_number FROM blocks - WHERE bch_name=? AND msg_type=1 AND msg_sub_type=? + WHERE LOWER(login)=LOWER(?) AND msg_type=1 AND msg_sub_type=? AND to_block_number=? AND to_block_hash=? - AND (to_bch_name=? OR to_bch_name IS NULL OR to_bch_name='') + AND fork_number=shine_canonical_fork(login,(SELECT substring(blockchain_name from '([0-9]{3})$')::INTEGER FROM solana_user_pda_current WHERE LOWER(login)=LOWER(?) LIMIT 1),block_number) ORDER BY block_number ASC """; try (PreparedStatement ps = c.prepareStatement(sql)) { - ps.setString(1, bch); + String login=ChannelsReadSupport.loginFromChainName(bch); + ps.setString(1, login); ps.setInt(2, subType); ps.setInt(3, targetBlock); ps.setBytes(4, targetHash); - ps.setString(5, bch); + ps.setString(5, login); try (ResultSet rs = ps.executeQuery()) { List out = new ArrayList<>(); while (rs.next()) out.add(mapRow(rs)); @@ -289,6 +335,7 @@ public class Net_GetMessageThread_Handler implements JsonMessageHandler { int blockNumber; byte[] blockHash; byte[] blockBytes; + String toLogin; String toBchName; Integer toBlockNumber; byte[] toBlockHash; diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetPersonalDiary_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetPersonalDiary_Handler.java index 2b2d6021..98daeaeb 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetPersonalDiary_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetPersonalDiary_Handler.java @@ -89,9 +89,8 @@ public class Net_GetPersonalDiary_Handler implements JsonMessageHandler { private String loadPrimaryBlockchainName(Connection c, String canonicalLogin) throws Exception { try (PreparedStatement ps = c.prepareStatement(""" SELECT blockchain_name - FROM blockchain_state - WHERE login = ? - ORDER BY blockchain_name + FROM solana_user_pda_current + WHERE LOWER(login)=LOWER(?) LIMIT 1 """)) { ps.setString(1, canonicalLogin); @@ -105,7 +104,8 @@ public class Net_GetPersonalDiary_Handler implements JsonMessageHandler { String order = asc ? "ASC" : "DESC"; List out = new ArrayList<>(); try (PreparedStatement ps = c.prepareStatement(""" - SELECT login, bch_name, block_number, block_hash, block_bytes, msg_sub_type + SELECT login, bch_name, block_number, block_hash, block_bytes, msg_sub_type, + to_login, to_bch_name, to_block_number, to_block_hash FROM blocks WHERE login = ? AND msg_type = ? ORDER BY block_number @@ -132,9 +132,9 @@ public class Net_GetPersonalDiary_Handler implements JsonMessageHandler { item.setLikedByMe(false); item.setRepliesCount(0); item.setRatingsCount(0); - item.setTargetBlockchainName(statusBody.toBchName()); - item.setTargetBlockNumber(statusBody.toBlockGlobalNumber()); - item.setTargetBlockHash(ChannelsReadSupport.toHex(statusBody.toBlockHashBytes())); + item.setTargetBlockchainName(rs.getString("to_bch_name")); + item.setTargetBlockNumber((Integer) rs.getObject("to_block_number")); + item.setTargetBlockHash(ChannelsReadSupport.toHex(rs.getBytes("to_block_hash"))); List versions = loadVersionsForDiaryItem( c, @@ -148,7 +148,8 @@ public class Net_GetPersonalDiary_Handler implements JsonMessageHandler { item.setVersionsTotal(versions.size()); item.setText(versions.get(versions.size() - 1).getText()); - fillTargetDetails(c, item, statusBody.toBchName(), statusBody.toBlockGlobalNumber(), statusBody.toBlockHashBytes()); + fillTargetDetails(c, item, rs.getString("to_login"), + (Integer) rs.getObject("to_block_number"), rs.getBytes("to_block_hash")); out.add(item); } } @@ -175,20 +176,20 @@ public class Net_GetPersonalDiary_Handler implements JsonMessageHandler { try (PreparedStatement ps = c.prepareStatement(""" SELECT block_number, block_hash, block_bytes FROM blocks - WHERE bch_name = ? + WHERE LOWER(login)=LOWER(?) AND msg_type = ? AND msg_sub_type = ? AND to_block_number = ? AND to_block_hash = ? - AND (to_bch_name = ? OR to_bch_name IS NULL OR to_bch_name = '') + AND fork_number=shine_canonical_fork(login,(SELECT substring(blockchain_name from '([0-9]{3})$')::INTEGER FROM solana_user_pda_current WHERE LOWER(login)=LOWER(?) LIMIT 1),block_number) ORDER BY block_number ASC """)) { - ps.setString(1, ownerBch); + ps.setString(1, ChannelsReadSupport.loginFromChainName(ownerBch)); ps.setInt(2, ChannelsReadSupport.MSG_TYPE_TEXT); ps.setInt(3, shine.db.MsgSubType.TEXT_EDIT_REPLY); ps.setInt(4, originalBlockNumber); ps.setBytes(5, originalBlockHash); - ps.setString(6, ownerBch); + ps.setString(6, ChannelsReadSupport.loginFromChainName(ownerBch)); try (ResultSet rs = ps.executeQuery()) { while (rs.next()) { ChannelsReadSupport.TextInfo editText = ChannelsReadSupport.parseTextAndTime(rs.getBytes("block_bytes")); @@ -208,24 +209,25 @@ public class Net_GetPersonalDiary_Handler implements JsonMessageHandler { private void fillTargetDetails(Connection c, Net_GetChannelMessages_Response.MessageItem item, - String targetBch, + String targetLogin, Integer targetBlockNumber, byte[] targetHash) throws Exception { - if (targetBch == null || targetBch.isBlank() || targetBlockNumber == null || targetHash == null || targetHash.length != 32) { + if (targetLogin == null || targetLogin.isBlank() || targetBlockNumber == null || targetHash == null || targetHash.length != 32) { return; } try (PreparedStatement ps = c.prepareStatement(""" - SELECT login, bch_name, block_number, block_hash, block_bytes, msg_sub_type + SELECT login, bch_name, block_number, block_hash, block_bytes, msg_sub_type, + to_login, to_bch_name, to_block_number, to_block_hash FROM blocks - WHERE bch_name = ? AND block_number = ? + WHERE LOWER(login) = LOWER(?) AND block_number = ? AND block_hash = ? + ORDER BY fork_number DESC LIMIT 1 """)) { - ps.setString(1, targetBch); + ps.setString(1, targetLogin); ps.setInt(2, targetBlockNumber); + ps.setBytes(3, targetHash); try (ResultSet rs = ps.executeQuery()) { if (!rs.next()) return; - byte[] actualHash = rs.getBytes("block_hash"); - if (actualHash == null || !java.util.Arrays.equals(actualHash, targetHash)) return; item.setTargetMsgSubType(rs.getInt("msg_sub_type")); item.setTargetAuthorLogin(rs.getString("login")); item.setTargetAuthorBlockchainName(rs.getString("bch_name")); diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_ListGroupChats200_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_ListGroupChats200_Handler.java index 5de34d74..57aa790c 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_ListGroupChats200_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_ListGroupChats200_Handler.java @@ -18,6 +18,8 @@ import java.sql.ResultSet; import java.util.ArrayList; import java.util.List; +/** @deprecated Chat200 is legacy/non-working/unused and is not maintained for segmented forks. */ +@Deprecated public class Net_ListGroupChats200_Handler implements JsonMessageHandler { private static final Logger log = LoggerFactory.getLogger(Net_ListGroupChats200_Handler.class); diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_ListSubscriptionsFeed_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_ListSubscriptionsFeed_Handler.java index 797295a8..25dc6905 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_ListSubscriptionsFeed_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_ListSubscriptionsFeed_Handler.java @@ -75,6 +75,9 @@ public class Net_ListSubscriptionsFeed_Handler implements JsonMessageHandler { channelRef.setChannelTypeCode(meta.channelTypeCode); channelRef.setChannelTypeVersion(meta.channelTypeVersion); channelRef.setPersonal(meta.channelTypeCode == 100); + channelRef.setDeleted(meta.deleted); + channelRef.setDeletedAtMs(meta.deletedAtMs); + channelRef.setDeletedBlockNumber(meta.deletedBlockNumber); Net_ListSubscriptionsFeed_Response.BlockRef rootRef = new Net_ListSubscriptionsFeed_Response.BlockRef(); rootRef.setBlockNumber(key.rootNumber); @@ -117,27 +120,14 @@ public class Net_ListSubscriptionsFeed_Handler implements JsonMessageHandler { private List loadOwnChannels(Connection c, String canonicalLogin) throws Exception { List out = new ArrayList<>(); - String bchSql = "SELECT blockchain_name FROM blockchain_state WHERE login=? ORDER BY blockchain_name"; - try (PreparedStatement bchPs = c.prepareStatement(bchSql)) { - bchPs.setString(1, canonicalLogin); - try (ResultSet bchRs = bchPs.executeQuery()) { - while (bchRs.next()) { - String bch = bchRs.getString("blockchain_name"); - out.add(new ChannelKey(canonicalLogin, bch, 0, new byte[32])); - - String chSql = "SELECT block_number,block_hash FROM blocks WHERE bch_name=? AND msg_type=? AND msg_sub_type=? ORDER BY block_number"; - try (PreparedStatement chPs = c.prepareStatement(chSql)) { - chPs.setString(1, bch); - chPs.setInt(2, ChannelsReadSupport.MSG_TYPE_TECH); - chPs.setInt(3, 1); - try (ResultSet chRs = chPs.executeQuery()) { - while (chRs.next()) { - out.add(new ChannelKey(canonicalLogin, bch, chRs.getInt("block_number"), chRs.getBytes("block_hash"))); - } - } - } - } - } + String activeBch = null; + try (PreparedStatement ps=c.prepareStatement("SELECT blockchain_name FROM solana_user_pda_current WHERE LOWER(login)=LOWER(?) LIMIT 1")){ + ps.setString(1,canonicalLogin);try(ResultSet rs=ps.executeQuery()){if(rs.next())activeBch=rs.getString(1);} + } + if(activeBch==null||activeBch.isBlank())return out; + out.add(new ChannelKey(canonicalLogin,activeBch,0,new byte[32])); + try(PreparedStatement ps=c.prepareStatement("SELECT owner_bch_name,channel_root_block_number,channel_root_block_hash FROM channel_names_state WHERE LOWER(owner_login)=LOWER(?) ORDER BY channel_root_block_number")){ + ps.setString(1,canonicalLogin);try(ResultSet rs=ps.executeQuery()){while(rs.next())out.add(new ChannelKey(canonicalLogin,rs.getString(1),rs.getInt(2),rs.getBytes(3)));} } return out; } @@ -145,10 +135,13 @@ public class Net_ListSubscriptionsFeed_Handler implements JsonMessageHandler { private List loadFollowedChannels(Connection c, String canonicalLogin, boolean onlyUserRoots) throws Exception { List out = new ArrayList<>(); String sql = """ - SELECT cs.to_login, cs.to_bch_name, COALESCE(cs.to_block_number,0) AS root_number, cs.to_block_hash + SELECT cs.to_login, + COALESCE(cn.owner_bch_name,(SELECT su.blockchain_name FROM solana_user_pda_current su WHERE LOWER(su.login)=LOWER(cs.to_login) LIMIT 1)) AS to_bch_name, + COALESCE(cs.to_block_number,0) AS root_number, cs.to_block_hash FROM connections_state cs + LEFT 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 cs.login=? AND cs.rel_type=? - ORDER BY cs.to_login, cs.to_bch_name, root_number + ORDER BY cs.to_login, root_number """; try (PreparedStatement ps = c.prepareStatement(sql)) { ps.setString(1, canonicalLogin); diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_MarkChannelMessagesSeen_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_MarkChannelMessagesSeen_Handler.java index 4f1c167c..6f38a45c 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_MarkChannelMessagesSeen_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_MarkChannelMessagesSeen_Handler.java @@ -48,13 +48,14 @@ public class Net_MarkChannelMessagesSeen_Handler implements JsonMessageHandler { Integer expectedRoot = req.getChannel() != null ? req.getChannel().getChannelRootBlockNumber() : null; String expectedOwnerBch = req.getChannel() != null ? req.getChannel().getOwnerBlockchainName() : null; + String expectedOwnerLogin = loginFromChainName(expectedOwnerBch); boolean strictChannelMatch = expectedRoot != null && expectedRoot >= 0 - && expectedOwnerBch != null && !expectedOwnerBch.isBlank(); + && expectedOwnerLogin != null && !expectedOwnerLogin.isBlank(); String existsSql = """ SELECT 1 FROM blocks - WHERE bch_name = ? + WHERE LOWER(login) = LOWER(?) AND block_number = ? AND block_hash = ? AND msg_type = ? @@ -65,7 +66,7 @@ public class Net_MarkChannelMessagesSeen_Handler implements JsonMessageHandler { String insertSql = """ INSERT INTO message_views_state ( - viewer_login, to_bch_name, to_block_number, to_block_hash, first_seen_at_ms + viewer_login, to_login, to_block_number, to_block_hash, first_seen_at_ms ) VALUES (?, ?, ?, ?, ?) ON CONFLICT DO NOTHING """; @@ -87,13 +88,15 @@ public class Net_MarkChannelMessagesSeen_Handler implements JsonMessageHandler { if (bch.isBlank() || no == null || no < 0) continue; if (!hashHex.matches("^[0-9a-f]{64}$")) continue; - if (strictChannelMatch && !bch.equals(expectedOwnerBch)) continue; + String targetLogin = loginFromChainName(bch); + if (targetLogin == null || targetLogin.isBlank()) continue; + if (strictChannelMatch && !targetLogin.equalsIgnoreCase(expectedOwnerLogin)) continue; - String key = bch + "|" + no + "|" + hashHex; + String key = targetLogin.toLowerCase(java.util.Locale.ROOT) + "|" + no + "|" + hashHex; if (!dedup.add(key)) continue; existsPs.clearParameters(); - existsPs.setString(1, bch); + existsPs.setString(1, targetLogin); existsPs.setInt(2, no); existsPs.setBytes(3, ChannelsReadSupport.hexToBytes(hashHex)); existsPs.setInt(4, ChannelsReadSupport.MSG_TYPE_TEXT); @@ -117,7 +120,7 @@ public class Net_MarkChannelMessagesSeen_Handler implements JsonMessageHandler { insertPs.clearParameters(); insertPs.setString(1, viewerLogin); - insertPs.setString(2, bch); + insertPs.setString(2, targetLogin); insertPs.setInt(3, no); insertPs.setBytes(4, ChannelsReadSupport.hexToBytes(hashHex)); insertPs.setLong(5, nowMs); @@ -137,4 +140,6 @@ public class Net_MarkChannelMessagesSeen_Handler implements JsonMessageHandler { return NetExceptionResponseFactory.error(req, WireCodes.Status.INTERNAL_ERROR, "internal_error", "Internal server error"); } } + private static String loginFromChainName(String bch) { if(bch==null)return null; int d=bch.lastIndexOf('-'); return d>0?bch.substring(0,d):bch; } + } diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/entyties/Net_GetChannelMessages_Response.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/entyties/Net_GetChannelMessages_Response.java index 9d3d5c5b..3fcb486a 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/entyties/Net_GetChannelMessages_Response.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/entyties/Net_GetChannelMessages_Response.java @@ -30,9 +30,13 @@ public class Net_GetChannelMessages_Response extends Net_Response { private String avaSha256; private Long avaSize; private Long metaUpdatedAtMs; + private Long createdAtMs; private Integer channelTypeCode; private Integer channelTypeVersion; private Integer subscribersCount; + private boolean deleted; + private long deletedAtMs; + private Integer deletedBlockNumber; private BlockRef channelRoot; public String getOwnerLogin() { return ownerLogin; } @@ -62,6 +66,9 @@ public class Net_GetChannelMessages_Response extends Net_Response { public Long getMetaUpdatedAtMs() { return metaUpdatedAtMs; } public void setMetaUpdatedAtMs(Long metaUpdatedAtMs) { this.metaUpdatedAtMs = metaUpdatedAtMs; } + public Long getCreatedAtMs() { return createdAtMs; } + public void setCreatedAtMs(Long createdAtMs) { this.createdAtMs = createdAtMs; } + public Integer getChannelTypeCode() { return channelTypeCode; } public void setChannelTypeCode(Integer channelTypeCode) { this.channelTypeCode = channelTypeCode; } @@ -71,6 +78,13 @@ public class Net_GetChannelMessages_Response extends Net_Response { public Integer getSubscribersCount() { return subscribersCount; } public void setSubscribersCount(Integer subscribersCount) { this.subscribersCount = subscribersCount; } + public boolean isDeleted() { return deleted; } + public void setDeleted(boolean deleted) { this.deleted = deleted; } + public long getDeletedAtMs() { return deletedAtMs; } + public void setDeletedAtMs(long deletedAtMs) { this.deletedAtMs = deletedAtMs; } + public Integer getDeletedBlockNumber() { return deletedBlockNumber; } + public void setDeletedBlockNumber(Integer deletedBlockNumber) { this.deletedBlockNumber = deletedBlockNumber; } + public BlockRef getChannelRoot() { return channelRoot; } public void setChannelRoot(BlockRef channelRoot) { this.channelRoot = channelRoot; } } diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/entyties/Net_ListSubscriptionsFeed_Response.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/entyties/Net_ListSubscriptionsFeed_Response.java index 457e3f2e..559b0555 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/entyties/Net_ListSubscriptionsFeed_Response.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/entyties/Net_ListSubscriptionsFeed_Response.java @@ -63,6 +63,9 @@ public class Net_ListSubscriptionsFeed_Response extends Net_Response { private Integer channelTypeCode; private Integer channelTypeVersion; private boolean personal; + private boolean deleted; + private long deletedAtMs; + private Integer deletedBlockNumber; private BlockRef channelRoot; public String getOwnerLogin() { return ownerLogin; } @@ -100,6 +103,12 @@ public class Net_ListSubscriptionsFeed_Response extends Net_Response { public boolean isPersonal() { return personal; } public void setPersonal(boolean personal) { this.personal = personal; } + public boolean isDeleted() { return deleted; } + public void setDeleted(boolean deleted) { this.deleted = deleted; } + public long getDeletedAtMs() { return deletedAtMs; } + public void setDeletedAtMs(long deletedAtMs) { this.deletedAtMs = deletedAtMs; } + public Integer getDeletedBlockNumber() { return deletedBlockNumber; } + public void setDeletedBlockNumber(Integer deletedBlockNumber) { this.deletedBlockNumber = deletedBlockNumber; } public BlockRef getChannelRoot() { return channelRoot; } public void setChannelRoot(BlockRef channelRoot) { this.channelRoot = channelRoot; } diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/connections/Net_AddCloseFriend_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/connections/Net_AddCloseFriend_Handler.java index bbb03fc4..d386fd7d 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/connections/Net_AddCloseFriend_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/connections/Net_AddCloseFriend_Handler.java @@ -44,7 +44,11 @@ public class Net_AddCloseFriend_Handler implements JsonMessageHandler { // Idempotent insert for close-friend relation. // Rely on PostgreSQL ON CONFLICT DO NOTHING. - insertCloseFriendIgnoreDuplicate(c, from, canonicalTo, targetBch); + byte[] targetHeaderHash = findHeaderHash(c, targetBch); + if (targetHeaderHash == null || targetHeaderHash.length != 32) { + return NetExceptionResponseFactory.error(req, 409, "HEADER_NOT_FOUND", "У целевого blockchain нет HEADER block 0"); + } + insertCloseFriendIgnoreDuplicate(c, from, canonicalTo, targetBch, targetHeaderHash); Net_AddCloseFriend_Response resp = new Net_AddCloseFriend_Response(); resp.setOp(req.getOp()); @@ -69,7 +73,7 @@ public class Net_AddCloseFriend_Handler implements JsonMessageHandler { } private String findPrimaryBlockchain(Connection c, String login) throws Exception { - String sql = "SELECT blockchain_name FROM blockchain_state WHERE LOWER(login) = LOWER(?) ORDER BY blockchain_name LIMIT 1"; + String sql = "SELECT blockchain_name FROM solana_user_pda_current WHERE LOWER(login)=LOWER(?) LIMIT 1"; try (PreparedStatement ps = c.prepareStatement(sql)) { ps.setString(1, login); try (ResultSet rs = ps.executeQuery()) { @@ -78,25 +82,37 @@ public class Net_AddCloseFriend_Handler implements JsonMessageHandler { } } + private byte[] findHeaderHash(Connection c, String blockchainName) throws Exception { + String login = blockchainName.substring(0, blockchainName.lastIndexOf('-')); + // Only fork1 owns HEADER #0 in segmented history. + String sql = "SELECT block_hash FROM blocks_store WHERE LOWER(login)=LOWER(?) AND block_number=0 ORDER BY fork_number ASC LIMIT 1"; + try (PreparedStatement ps = c.prepareStatement(sql)) { + ps.setString(1, login); + try (ResultSet rs = ps.executeQuery()) { + return rs.next() ? rs.getBytes("block_hash") : null; + } + } + } + private void insertCloseFriendIgnoreDuplicate(Connection c, String login, String toLogin, - String toBchName) throws Exception { + String toBchName, + byte[] targetHeaderHash) throws Exception { String sql = """ INSERT INTO connections_state ( - login, rel_type, to_login, to_bch_name, to_block_number, to_block_hash + login, rel_type, to_login, to_block_number, to_block_hash ) - VALUES (?, ?, ?, ?, ?, ?) - ON CONFLICT (login, rel_type, to_login, to_bch_name, to_block_number, to_block_hash) DO NOTHING + VALUES (?, ?, ?, ?, ?) + ON CONFLICT (login, rel_type, to_login, to_block_number, to_block_hash) DO NOTHING """; try (PreparedStatement ps = c.prepareStatement(sql)) { ps.setString(1, login); ps.setInt(2, MsgSubType.CONNECTION_CLOSE_FRIEND); ps.setString(3, toLogin); - ps.setString(4, toBchName); - ps.setInt(5, 0); - ps.setBytes(6, new byte[32]); + ps.setInt(4, 0); + ps.setBytes(5, targetHeaderHash); ps.executeUpdate(); } } diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/connections/Net_GetUserConnectionsGraph_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/connections/Net_GetUserConnectionsGraph_Handler.java index 69e4c736..c08e99bc 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/connections/Net_GetUserConnectionsGraph_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/connections/Net_GetUserConnectionsGraph_Handler.java @@ -6,6 +6,7 @@ import server.logic.ws_protocol.JSON.entyties.Net_Response; import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler; import server.logic.ws_protocol.JSON.handlers.connections.entyties.Net_GetUserConnectionsGraph_Request; import server.logic.ws_protocol.JSON.handlers.connections.entyties.Net_GetUserConnectionsGraph_Response; +import server.logic.ws_protocol.JSON.handlers.profile.AvatarValueParser; import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory; import server.logic.ws_protocol.WireCodes; import shine.db.MsgSubType; @@ -234,7 +235,7 @@ public class Net_GetUserConnectionsGraph_Handler implements JsonMessageHandler { meta.accountRole=rs.getString("account_role"); meta.shineStatus=rs.getString("shine_status"); meta.gender=normalizeGender(rs.getString("gender_value")); meta.official="primary".equals(meta.accountRole); meta.shine="shining".equals(meta.shineStatus); meta.primaryConfirmationsCount=rs.getInt("primary_confirmations_count"); meta.shineConfirmationsCount=rs.getInt("shine_confirmations_count"); - meta.avatarAr=extractArAvatarTxId(rs.getString("avatar_value")); out.put(normKey(login),meta); + meta.avatarValue=String.valueOf(rs.getString("avatar_value") == null ? "" : rs.getString("avatar_value")); out.put(normKey(login),meta); }} } return out; @@ -291,11 +292,12 @@ public class Net_GetUserConnectionsGraph_Handler implements JsonMessageHandler { return txId; } - private Net_GetUserConnectionsGraph_Response.AvatarItem makeAvatarItem(String avatarAr) { - String txId = String.valueOf(avatarAr == null ? "" : avatarAr).trim(); - if (txId.isEmpty()) return null; + private Net_GetUserConnectionsGraph_Response.AvatarItem makeAvatarItem(String avatarValue) { + AvatarValueParser.Parsed parsed = AvatarValueParser.parse(avatarValue); + if (!parsed.ok()) return null; Net_GetUserConnectionsGraph_Response.AvatarItem avatar = new Net_GetUserConnectionsGraph_Response.AvatarItem(); - avatar.setAr(txId); + avatar.setAr(parsed.ar()); + avatar.setSha256Hex(parsed.sha256Hex()); return avatar; } @@ -315,7 +317,7 @@ public class Net_GetUserConnectionsGraph_Handler implements JsonMessageHandler { it.setLogin(clean); it.setGender(gender); it.setGenderLabel(genderLabel(gender)); - it.setAvatar(makeAvatarItem(meta == null ? null : meta.avatarAr)); + it.setAvatar(makeAvatarItem(meta == null ? null : meta.avatarValue)); items.add(it); } return items; @@ -354,7 +356,7 @@ public class Net_GetUserConnectionsGraph_Handler implements JsonMessageHandler { it.setShine(shine); it.setOfficialLabel(official ? "официальный" : "неофициальный"); it.setShineLabel(shine ? "сияющий" : "несияющий"); - it.setAvatar(makeAvatarItem(meta == null ? null : meta.avatarAr)); + it.setAvatar(makeAvatarItem(meta == null ? null : meta.avatarValue)); items.add(it); } return items; @@ -370,6 +372,6 @@ public class Net_GetUserConnectionsGraph_Handler implements JsonMessageHandler { private int shineConfirmationsCount = 0; private boolean official = false; private boolean shine = false; - private String avatarAr = null; + private String avatarValue = ""; } } diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/connections/Net_ListContacts_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/connections/Net_ListContacts_Handler.java index 827d7ab2..ca63c317 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/connections/Net_ListContacts_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/connections/Net_ListContacts_Handler.java @@ -6,6 +6,7 @@ import server.logic.ws_protocol.JSON.entyties.Net_Response; import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler; import server.logic.ws_protocol.JSON.handlers.connections.entyties.Net_ListContacts_Request; import server.logic.ws_protocol.JSON.handlers.connections.entyties.Net_ListContacts_Response; +import server.logic.ws_protocol.JSON.handlers.profile.AvatarValueParser; import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory; import server.logic.ws_protocol.WireCodes; import shine.db.dao.DmDialogStateDAO; @@ -59,12 +60,12 @@ public class Net_ListContacts_Handler implements JsonMessageHandler { } private static Net_ListContacts_Response.Avatar parseAvatar(String value) { Net_ListContacts_Response.Avatar out = new Net_ListContacts_Response.Avatar(); - String raw = value == null ? "" : value.trim(); - java.util.regex.Matcher ar = java.util.regex.Pattern.compile("AR:([A-Za-z0-9_-]{43})").matcher(raw); - if (ar.find()) out.setAr(ar.group(1)); - java.util.regex.Matcher sha = java.util.regex.Pattern.compile("SHA256:([A-Fa-f0-9]{64})").matcher(raw); - if (sha.find()) out.setSha256Hex(sha.group(1).toLowerCase()); + AvatarValueParser.Parsed parsed = AvatarValueParser.parse(value); + if (!parsed.ok()) return out; + out.setAr(parsed.ar()); + out.setSha256Hex(parsed.sha256Hex()); return out; } + } diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/connections/entyties/Net_GetUserConnectionsGraph_Response.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/connections/entyties/Net_GetUserConnectionsGraph_Response.java index 285d44dc..80f23283 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/connections/entyties/Net_GetUserConnectionsGraph_Response.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/connections/entyties/Net_GetUserConnectionsGraph_Response.java @@ -39,9 +39,12 @@ public class Net_GetUserConnectionsGraph_Response extends Net_Response { public static class AvatarItem { private String ar; + private String sha256Hex; public String getAr() { return ar; } public void setAr(String ar) { this.ar = ar; } + public String getSha256Hex() { return sha256Hex; } + public void setSha256Hex(String sha256Hex) { this.sha256Hex = sha256Hex; } } public static class RelativeItem { diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/KeyRotationApiSupport.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/KeyRotationApiSupport.java new file mode 100644 index 00000000..d68af9a2 --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/KeyRotationApiSupport.java @@ -0,0 +1,120 @@ +package server.logic.ws_protocol.JSON.handlers.keyRotation; + +import server.logic.ws_protocol.JSON.handlers.keyRotation.entyties.Net_KeyRotationState_Response; +import shine.db.KeyEncodingUtil; +import shine.db.entities.KeyRotationSessionEntry; +import shine.db.entities.KeyRotationStatus; + +import java.util.Arrays; +import java.util.Base64; + +final class KeyRotationApiSupport { + private KeyRotationApiSupport() {} + + static String normalizePublicKey32(String raw) { + String normalized = KeyEncodingUtil.normalizeKeyToBase64_32(raw); + if (normalized == null || normalized.isBlank()) { + throw new IllegalArgumentException("public key is empty"); + } + try { + byte[] decoded = Base64.getDecoder().decode(normalized); + if (decoded.length != 32) throw new IllegalArgumentException("public key must be 32 bytes"); + return Base64.getEncoder().encodeToString(decoded); + } catch (IllegalArgumentException e) { + throw new IllegalArgumentException("public key must be Base58/Base64 of 32 bytes", e); + } + } + + static byte[] parseHash32(String hex) { + if (hex == null) throw new IllegalArgumentException("hash is null"); + String s = hex.trim(); + if (s.length() != 64) throw new IllegalArgumentException("hash must contain 64 hex chars"); + byte[] out = new byte[32]; + for (int i = 0; i < 32; i++) { + int hi = Character.digit(s.charAt(i * 2), 16); + int lo = Character.digit(s.charAt(i * 2 + 1), 16); + if (hi < 0 || lo < 0) throw new IllegalArgumentException("hash contains non-hex chars"); + out[i] = (byte) ((hi << 4) | lo); + } + return out; + } + + static String toHex(byte[] bytes) { + if (bytes == null) return null; + StringBuilder sb = new StringBuilder(bytes.length * 2); + for (byte b : bytes) sb.append(String.format("%02x", b & 0xff)); + return sb.toString(); + } + + static String nextBlockchainName(String login, String source) { + if (login == null || login.isBlank() || source == null || source.length() < 5) { + throw new IllegalArgumentException("bad source blockchain name"); + } + String prefix = login + "-"; + if (!source.startsWith(prefix) || source.length() != prefix.length() + 3) { + throw new IllegalArgumentException("source blockchain name does not match login"); + } + String suffix = source.substring(prefix.length()); + if (!suffix.chars().allMatch(Character::isDigit)) { + throw new IllegalArgumentException("bad blockchain suffix"); + } + int n = Integer.parseInt(suffix); + if (n < 1 || n >= 999) throw new IllegalArgumentException("blockchain fork limit reached"); + return login + "-" + String.format("%03d", n + 1); + } + + static void requireKeysChangedAndDistinct(String oldRoot, String oldBlockchain, String oldClient, + String newRoot, String newBlockchain, String newClient) { + java.util.Set oldKeys = java.util.Set.of(oldRoot, oldBlockchain, oldClient); + java.util.Set newKeys = java.util.Set.of(newRoot, newBlockchain, newClient); + if (newKeys.size() != 3) { + throw new IllegalArgumentException("new root/blockchain/client keys must be distinct"); + } + for (String newKey : newKeys) { + if (oldKeys.contains(newKey)) { + throw new IllegalArgumentException("new keys must not reuse any key from the old key set"); + } + } + } + + static boolean hashesEqual(byte[] a, byte[] b) { + return Arrays.equals(a, b); + } + + static Net_KeyRotationState_Response response(String op, String requestId, KeyRotationSessionEntry e) { + Net_KeyRotationState_Response r = new Net_KeyRotationState_Response(); + r.setOp(op); + r.setRequestId(requestId); + r.setStatus(200); + if (e == null) { + r.setRotationStatus(KeyRotationStatus.NONE.name()); + return r; + } + r.setRotationSessionId(e.getId()); + r.setRotationStatus(e.getStatus().name()); + r.setSourceBlockchainName(e.getSourceBlockchainName()); + r.setCandidateBlockchainName(e.getCandidateBlockchainName()); + r.setOldRootKey(e.getOldRootKey()); + r.setOldBlockchainKey(e.getOldBlockchainKey()); + r.setOldClientKey(e.getOldClientKey()); + r.setNewRootKey(e.getNewRootKey()); + r.setNewBlockchainKey(e.getNewBlockchainKey()); + r.setNewClientKey(e.getNewClientKey()); + r.setForkFromBlock(e.getForkFromBlock()); + r.setForkFromHash(toHex(e.getForkFromHash())); + r.setSourceTipBlock(e.getSourceTipBlock()); + r.setSourceTipHash(toHex(e.getSourceTipHash())); + r.setReasonCode(e.getReasonCode()); + r.setComment(e.getComment()); + r.setProgressCurrent(e.getProgressCurrent()); + r.setProgressTotal(e.getProgressTotal()); + r.setPdaRotationSignature(e.getPdaRotationSignature()); + r.setWalletMigrationStatus(e.getWalletMigrationStatus()); + r.setMessageMigrationStatus(e.getMessageMigrationStatus()); + r.setLastError(e.getLastError()); + r.setRetryCount(e.getRetryCount()); + r.setCreatedAtMs(e.getCreatedAtMs()); + r.setUpdatedAtMs(e.getUpdatedAtMs()); + return r; + } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationAbort_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationAbort_Handler.java new file mode 100644 index 00000000..4e6c9036 --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationAbort_Handler.java @@ -0,0 +1,36 @@ +package server.logic.ws_protocol.JSON.handlers.keyRotation; + +import server.logic.ws_protocol.JSON.ConnectionContext; +import server.logic.ws_protocol.JSON.entyties.Net_Request; +import server.logic.ws_protocol.JSON.entyties.Net_Response; +import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler; +import server.logic.ws_protocol.JSON.handlers.keyRotation.entyties.Net_KeyRotationAbort_Request; +import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory; +import shine.db.dao.KeyRotationSessionsDAO; +import shine.db.entities.KeyRotationSessionEntry; +import shine.db.entities.KeyRotationStatus; + +/** Прерывание разрешено только пока Solana-транзакция ротации ещё не могла быть отправлена. */ +public final class Net_KeyRotationAbort_Handler implements JsonMessageHandler { + private final KeyRotationSessionsDAO rotations = KeyRotationSessionsDAO.getInstance(); + + @Override + public Net_Response handle(Net_Request baseReq, ConnectionContext ctx) { + Net_KeyRotationAbort_Request req = (Net_KeyRotationAbort_Request) baseReq; + if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) { + return NetExceptionResponseFactory.error(req, 401, "AUTH_REQUIRED", "Нужна авторизованная пользовательская сессия"); + } + try { + KeyRotationSessionEntry current = rotations.getActiveByLogin(ctx.getLogin().trim()); + if (current == null) return KeyRotationApiSupport.response(req.getOp(), req.getRequestId(), null); + if (current.getStatus() != KeyRotationStatus.COPYING_CHAIN && current.getStatus() != KeyRotationStatus.CHAIN_READY) { + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_ABORT_TOO_LATE", + "После начала ротации PDA процесс можно только завершить"); + } + KeyRotationSessionEntry aborted = rotations.transition(current.getId(), current.getStatus(), KeyRotationStatus.ABORTED); + return KeyRotationApiSupport.response(req.getOp(), req.getRequestId(), aborted); + } catch (Exception e) { + return NetExceptionResponseFactory.error(req, 500, "KEY_ROTATION_ABORT_FAILED", "Не удалось прервать смену ключей"); + } + } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationAddBlock_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationAddBlock_Handler.java new file mode 100644 index 00000000..c6cac594 --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationAddBlock_Handler.java @@ -0,0 +1,240 @@ +package server.logic.ws_protocol.JSON.handlers.keyRotation; + +import blockchain.BchBlockEntry; +import blockchain.BchCryptoVerifier; +import blockchain.MsgSubType; +import blockchain.ShineProtocolTags; +import blockchain.body.ForkBody; +import server.logic.ws_protocol.Base64Ws; +import server.logic.ws_protocol.JSON.ConnectionContext; +import server.logic.ws_protocol.JSON.entyties.Net_Request; +import server.logic.ws_protocol.JSON.entyties.Net_Response; +import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler; +import server.logic.ws_protocol.JSON.handlers.blockchain.Net_AddBlock_Handler_utils.BlockchainLocks; +import server.logic.ws_protocol.JSON.handlers.keyRotation.entyties.Net_KeyRotationAddBlock_Request; +import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory; +import server.sync.ArweavePublishSignal; +import shine.db.DbController; +import shine.db.dao.BlocksDAO; +import shine.db.dao.KeyRotationCandidateBlocksDAO; +import shine.db.dao.KeyRotationSessionsDAO; +import shine.db.entities.BlockEntry; +import shine.db.entities.KeyRotationCandidateBlockEntry; +import shine.db.entities.KeyRotationSessionEntry; +import shine.db.entities.KeyRotationStatus; + +import java.sql.Connection; +import java.util.Arrays; +import java.util.Base64; +import java.util.concurrent.locks.ReentrantLock; + +/** + * Принимает DataItem будущего fork во время COPYING_CHAIN. + * Candidate-блок сохраняется отдельно от blocks и не влияет на materialized state. + */ +public final class Net_KeyRotationAddBlock_Handler implements JsonMessageHandler { + private final KeyRotationSessionsDAO rotations = KeyRotationSessionsDAO.getInstance(); + private final KeyRotationCandidateBlocksDAO candidates = KeyRotationCandidateBlocksDAO.getInstance(); + private final BlocksDAO blocks = BlocksDAO.getInstance(); + private final shine.db.dao.CanonicalChainResolver canonicalChain = shine.db.dao.CanonicalChainResolver.getInstance(); + + @Override + public Net_Response handle(Net_Request baseReq, ConnectionContext ctx) { + Net_KeyRotationAddBlock_Request req = (Net_KeyRotationAddBlock_Request) baseReq; + if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) { + return NetExceptionResponseFactory.error(req, 401, "AUTH_REQUIRED", "Нужна авторизованная пользовательская сессия"); + } + if (req.getBlockNumber() < 0 || req.getBlockBytesB64() == null || req.getBlockBytesB64().isBlank()) { + return NetExceptionResponseFactory.error(req, 400, "KEY_ROTATION_BAD_BLOCK", "blockNumber и blockBytesB64 обязательны"); + } + + String login = ctx.getLogin().trim(); + KeyRotationSessionEntry initial; + try { + initial = rotations.getActiveByLogin(login); + } catch (Exception e) { + return NetExceptionResponseFactory.error(req, 500, "KEY_ROTATION_DB_ERROR", "Не удалось прочитать состояние смены ключей"); + } + if (initial == null || initial.getStatus() != KeyRotationStatus.COPYING_CHAIN) { + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_NOT_COPYING", "Ротация не находится на этапе COPYING_CHAIN"); + } + + ReentrantLock lock = BlockchainLocks.lockFor(initial.getCandidateBlockchainName()); + lock.lock(); + try (Connection c = DbController.getInstance().getConnection()) { + KeyRotationSessionEntry session = rotations.getActiveByLogin(c, login); + if (session == null || session.getStatus() != KeyRotationStatus.COPYING_CHAIN) { + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_NOT_COPYING", "Ротация больше не находится на этапе COPYING_CHAIN"); + } + + int stored = candidates.countStored(c, session.getId()); + int expectedBlockNumber = session.getForkFromBlock() + 1; + KeyRotationCandidateBlockEntry existing = candidates.getByNumber(c, session.getId(), req.getBlockNumber()); + if (existing != null) { + BchBlockEntry repeated; + try { repeated = new BchBlockEntry(Base64Ws.decode(req.getBlockBytesB64())); } + catch (Exception e) { return NetExceptionResponseFactory.error(req, 400, "KEY_ROTATION_BAD_BLOCK", "Не удалось распарсить DataItem"); } + if (!Arrays.equals(existing.getBlockHash(), repeated.getHash32()) || !Arrays.equals(existing.getDataItemId(), repeated.getDataItemId32())) { + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_BLOCK_CONFLICT", "TECH_FORK уже сохранён с другим содержимым"); + } + return KeyRotationApiSupport.response(req.getOp(), req.getRequestId(), session); + } + if (req.getBlockNumber() != expectedBlockNumber) { + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_BLOCK_OUT_OF_ORDER", "Segmented fork принимает только TECH_FORK #" + expectedBlockNumber); + } + if (stored >= 1) { + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_CHAIN_ALREADY_COMPLETE", "TECH_FORK уже принят сервером"); + } + + final byte[] raw; + final BchBlockEntry block; + try { + raw = Base64Ws.decode(req.getBlockBytesB64()); + block = new BchBlockEntry(raw); + block.body.check(); + } catch (Exception e) { + return NetExceptionResponseFactory.error(req, 400, "KEY_ROTATION_BAD_BLOCK", "Некорректный SHiNE/ANS-104 блок"); + } + if (block.blockNumber != req.getBlockNumber()) { + return NetExceptionResponseFactory.error(req, 400, "KEY_ROTATION_BLOCK_NUMBER_MISMATCH", "blockNumber запроса не совпадает с блоком"); + } + if (!block.getDataItem().hasTag(ShineProtocolTags.APP_TAG_NAME, ShineProtocolTags.APP_TAG_VALUE)) { + return NetExceptionResponseFactory.error(req, 400, "KEY_ROTATION_BAD_APP_TAG", "Отсутствует App=" + ShineProtocolTags.APP_TAG_VALUE); + } + String expectedTypeTag = expectedTypeTag(block); + String actualTypeTag = block.getDataItem().tagValue(ShineProtocolTags.TYPE_TAG_NAME); + if (expectedTypeTag != null ? !expectedTypeTag.equals(actualTypeTag) : actualTypeTag != null) { + return NetExceptionResponseFactory.error(req, 400, "KEY_ROTATION_BAD_TYPE_TAG", "Некорректный t-тег candidate DataItem"); + } + if (!requestPrevHashMatches(req.getPrevBlockHash(), block.prevHash32)) { + return NetExceptionResponseFactory.error(req, 400, "KEY_ROTATION_PREV_HASH_MISMATCH", "prevBlockHash запроса не совпадает с блоком"); + } + byte[] expectedBack32 = new byte[32]; + if (block.blockNumber >= 32) { + expectedBack32 = canonicalChain.getHash(c, session.getSourceBlockchainName(), block.blockNumber - 32); + if (expectedBack32 == null || expectedBack32.length != 32) { + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_BACK32_SOURCE_MISSING", "Нет канонического блока N-32 для проверки back32Hash"); + } + } + if (!Arrays.equals(block.back32Hash32, expectedBack32)) { + return NetExceptionResponseFactory.error(req, 400, "KEY_ROTATION_BACK32_HASH_MISMATCH", "back32Hash candidate-блока не совпадает с N-32"); + } + + byte[] newBlockchainKey; + try { + newBlockchainKey = Base64.getDecoder().decode(session.getNewBlockchainKey()); + } catch (Exception e) { + return NetExceptionResponseFactory.error(req, 500, "KEY_ROTATION_BAD_STORED_KEY", "Некорректный new blockchain public key в rotation session"); + } + if (newBlockchainKey.length != 32 || !BchCryptoVerifier.verifyBlock(block, newBlockchainKey)) { + return NetExceptionResponseFactory.error(req, 400, "KEY_ROTATION_BAD_SIGNATURE", "Candidate DataItem должен быть подписан новым blockchain key"); + } + + String validationError; + try { + validationError = validateCandidate(c, session, block); + } catch (Exception e) { + return NetExceptionResponseFactory.error(req, 500, "KEY_ROTATION_VALIDATE_FAILED", "Не удалось проверить candidate-блок"); + } + if (validationError != null) { + return NetExceptionResponseFactory.error(req, 400, validationError, "Candidate-блок не соответствует выбранному fork"); + } + + KeyRotationCandidateBlockEntry entry = new KeyRotationCandidateBlockEntry(); + entry.setRotationSessionId(session.getId()); + entry.setLogin(login); + entry.setCandidateBlockchainName(session.getCandidateBlockchainName()); + entry.setBlockNumber(block.blockNumber); + entry.setBlockHash(block.getHash32()); + entry.setDataItemId(block.getDataItemId32()); + entry.setBlockBytes(raw); + entry.setCreatedAtMs(System.currentTimeMillis()); + + boolean oldAutoCommit = c.getAutoCommit(); + c.setAutoCommit(false); + try { + candidates.insertOrGet(c, entry); + c.commit(); + } catch (Exception e) { + c.rollback(); + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_BLOCK_CONFLICT", "Не удалось сохранить candidate-блок"); + } finally { + c.setAutoCommit(oldAutoCommit); + } + + // Как и обычный пользовательский блок, candidate сразу ставится в неблокирующую Turbo-очередь. + // При сетевой ошибке pending-флаг остаётся TRUE и его подберёт плановый retry. + ArweavePublishSignal.keyRotationCandidateAccepted(entry.getDataItemId()); + + // progressCurrent обновляет Arweave publisher только после реальной публикации. + KeyRotationSessionEntry refreshed = rotations.getActiveByLogin(login); + return KeyRotationApiSupport.response(req.getOp(), req.getRequestId(), refreshed == null ? session : refreshed); + } catch (Exception e) { + return NetExceptionResponseFactory.error(req, 500, "KEY_ROTATION_ADD_BLOCK_FAILED", "Не удалось принять candidate-блок"); + } finally { + lock.unlock(); + } + } + + private String validateCandidate(Connection c, KeyRotationSessionEntry session, BchBlockEntry candidate) throws Exception { + int techForkNumber = session.getForkFromBlock() + 1; + if (candidate.blockNumber != techForkNumber) return "KEY_ROTATION_UNEXPECTED_BLOCK_NUMBER"; + if ((candidate.type & 0xFFFF) != 0 + || (candidate.subType & 0xFFFF) != (MsgSubType.TECH_FORK & 0xFFFF) + || !(candidate.body instanceof ForkBody fork)) { + return "KEY_ROTATION_TECH_FORK_REQUIRED"; + } + if (!Arrays.equals(candidate.prevHash32, session.getForkFromHash())) return "KEY_ROTATION_TECH_FORK_PREV_HASH"; + + BlockEntry forkSourceEntry = canonicalChain.getBlock(c, session.getSourceBlockchainName(), session.getForkFromBlock()); + BlockEntry tipSourceEntry = blocks.getByNumber(c, session.getSourceBlockchainName(), session.getSourceTipBlock()); + if (forkSourceEntry == null || tipSourceEntry == null) return "KEY_ROTATION_SOURCE_BLOCK_MISSING"; + BchBlockEntry forkSource = new BchBlockEntry(forkSourceEntry.getBlockBytes()); + BchBlockEntry tipSource = new BchBlockEntry(tipSourceEntry.getBlockBytes()); + + byte[] oldBlockchain = Base64.getDecoder().decode(session.getOldBlockchainKey()); + if (!Arrays.equals(fork.parentBlockchainKey32, oldBlockchain)) return "KEY_ROTATION_TECH_FORK_PARENT_KEY"; + if (fork.forkPointBlockNumber != session.getForkFromBlock()) return "KEY_ROTATION_TECH_FORK_POINT"; + if (!Arrays.equals(fork.forkPointBlockHash32, session.getForkFromHash())) return "KEY_ROTATION_TECH_FORK_POINT_HASH"; + if (fork.forkPointTimestampMs != Math.multiplyExact(forkSource.timestamp, 1000L)) return "KEY_ROTATION_TECH_FORK_POINT_TIME"; + if (fork.parentTipBlockNumber != session.getSourceTipBlock()) return "KEY_ROTATION_TECH_FORK_TIP"; + if (!Arrays.equals(fork.parentTipBlockHash32, session.getSourceTipHash())) return "KEY_ROTATION_TECH_FORK_TIP_HASH"; + if (fork.parentTipTimestampMs != Math.multiplyExact(tipSource.timestamp, 1000L)) return "KEY_ROTATION_TECH_FORK_TIP_TIME"; + if (fork.discardedBlocksCount != session.getSourceTipBlock() - session.getForkFromBlock()) return "KEY_ROTATION_TECH_FORK_DISCARDED"; + if (fork.reasonCode != session.getReasonCode()) return "KEY_ROTATION_TECH_FORK_REASON"; + if (!normalizeComment(fork.comment).equals(normalizeComment(session.getComment()))) return "KEY_ROTATION_TECH_FORK_COMMENT"; + return null; + } + + private static boolean requestPrevHashMatches(String raw, byte[] actual) { + if (raw == null || raw.isBlank()) { + return isZero32(actual); + } + try { + return Arrays.equals(KeyRotationApiSupport.parseHash32(raw), actual); + } catch (Exception e) { + return false; + } + } + + private static boolean isZero32(byte[] value) { + if (value == null || value.length != 32) return false; + for (byte b : value) if (b != 0) return false; + return true; + } + + private static String normalizeComment(String value) { + if (value == null) return ""; + return value.trim().replace("\r\n", "\n").replace('\r', '\n'); + } + private static String expectedTypeTag(BchBlockEntry block) { + int type = block.type & 0xffff; + return switch (type) { + case 0 -> "tech"; + case 3 -> "conn"; + case 4 -> "prof"; + default -> null; + }; + } + +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationContinue_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationContinue_Handler.java new file mode 100644 index 00000000..028e8a8c --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationContinue_Handler.java @@ -0,0 +1,71 @@ +package server.logic.ws_protocol.JSON.handlers.keyRotation; + +import server.logic.ws_protocol.JSON.ConnectionContext; +import server.logic.ws_protocol.JSON.entyties.Net_Request; +import server.logic.ws_protocol.JSON.entyties.Net_Response; +import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler; +import server.logic.ws_protocol.JSON.handlers.keyRotation.entyties.Net_KeyRotationContinue_Request; +import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory; +import shine.db.dao.CurrentUsersDAO; +import shine.db.dao.KeyRotationSessionsDAO; +import shine.db.dao.SignedMessagesDAO; +import shine.db.entities.KeyRotationSessionEntry; +import shine.db.entities.KeyRotationStatus; + +/** Координирует реально выполненные wallet/DM этапы после rebuild. */ +public final class Net_KeyRotationContinue_Handler implements JsonMessageHandler { + private final KeyRotationSessionsDAO rotations = KeyRotationSessionsDAO.getInstance(); + + @Override + public Net_Response handle(Net_Request baseReq, ConnectionContext ctx) { + Net_KeyRotationContinue_Request req = (Net_KeyRotationContinue_Request) baseReq; + if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) { + return NetExceptionResponseFactory.error(req, 401, "AUTH_REQUIRED", "Нужна авторизованная пользовательская сессия"); + } + try { + String login = ctx.getLogin().trim(); + KeyRotationSessionEntry current = rotations.getActiveByLogin(login); + if (current == null) return KeyRotationApiSupport.response(req.getOp(), req.getRequestId(), null); + + if (current.getStatus() == KeyRotationStatus.WALLET_MIGRATION) { + String walletStatus = String.valueOf(req.getWalletMigrationStatus() == null ? "" : req.getWalletMigrationStatus()).trim().toUpperCase(); + if (!"COMPLETE".equals(walletStatus) && !"SKIPPED".equals(walletStatus)) { + return NetExceptionResponseFactory.error(req, 400, "KEY_ROTATION_BAD_WALLET_STATUS", + "walletMigrationStatus должен быть COMPLETE или SKIPPED"); + } + rotations.setMigrationSubStatus(current.getId(), "wallet_migration_status", walletStatus); + current = rotations.transition(current.getId(), KeyRotationStatus.WALLET_MIGRATION, KeyRotationStatus.MESSAGE_MIGRATION); + return KeyRotationApiSupport.response(req.getOp(), req.getRequestId(), current); + } + if (current.getStatus() == KeyRotationStatus.MESSAGE_MIGRATION) { + long remaining = SignedMessagesDAO.getInstance() + .countMessagesNeedingReencryption(login, current.getUpdatedAtMs()); + if (remaining > 0) { + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_DM_PENDING", + "Остались неперешифрованные личные сообщения: " + remaining); + } + rotations.setMigrationSubStatus(current.getId(), "message_migration_status", "COMPLETE"); + current = rotations.transition(current.getId(), KeyRotationStatus.MESSAGE_MIGRATION, KeyRotationStatus.FINALIZING); + current = rotations.transition(current.getId(), KeyRotationStatus.FINALIZING, KeyRotationStatus.COMPLETE); + refreshCurrentUser(ctx, login); + return KeyRotationApiSupport.response(req.getOp(), req.getRequestId(), current); + } + if (current.getStatus() == KeyRotationStatus.FINALIZING) { + current = rotations.transition(current.getId(), KeyRotationStatus.FINALIZING, KeyRotationStatus.COMPLETE); + refreshCurrentUser(ctx, login); + return KeyRotationApiSupport.response(req.getOp(), req.getRequestId(), current); + } + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_CONTINUE_NOT_ALLOWED", + "На текущем этапе продолжение этой операцией не требуется"); + } catch (Exception e) { + return NetExceptionResponseFactory.error(req, 500, "KEY_ROTATION_CONTINUE_FAILED", + "Не удалось продолжить смену ключей"); + } + } + + + private static void refreshCurrentUser(ConnectionContext ctx, String login) throws Exception { + var fresh = CurrentUsersDAO.getInstance().getByLogin(login); + if (fresh != null) ctx.setCurrentUser(fresh); + } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationFinishChain_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationFinishChain_Handler.java new file mode 100644 index 00000000..56def79e --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationFinishChain_Handler.java @@ -0,0 +1,192 @@ +package server.logic.ws_protocol.JSON.handlers.keyRotation; + +import blockchain.BchBlockEntry; +import blockchain.BchCryptoVerifier; +import blockchain.MsgSubType; +import blockchain.ShineProtocolTags; +import blockchain.body.ForkBody; +import server.logic.ws_protocol.JSON.ConnectionContext; +import server.logic.ws_protocol.JSON.entyties.Net_Request; +import server.logic.ws_protocol.JSON.entyties.Net_Response; +import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler; +import server.logic.ws_protocol.JSON.handlers.blockchain.Net_AddBlock_Handler_utils.BlockchainLocks; +import server.logic.ws_protocol.JSON.handlers.keyRotation.entyties.Net_KeyRotationFinishChain_Request; +import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory; +import shine.db.DbController; +import shine.db.dao.BlocksDAO; +import shine.db.dao.KeyRotationCandidateBlocksDAO; +import shine.db.dao.KeyRotationSessionsDAO; +import shine.db.entities.BlockEntry; +import shine.db.entities.KeyRotationCandidateBlockEntry; +import shine.db.entities.KeyRotationSessionEntry; +import shine.db.entities.KeyRotationStatus; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.sql.Connection; +import java.util.Arrays; +import java.util.Base64; +import java.util.List; +import java.util.concurrent.locks.ReentrantLock; + +/** + * Проверяет, что candidate-chain полностью сохранена и опубликована в Arweave/Turbo, + * затем переводит ротацию COPYING_CHAIN -> CHAIN_READY. + */ +public final class Net_KeyRotationFinishChain_Handler implements JsonMessageHandler { + private static final Logger log = LoggerFactory.getLogger(Net_KeyRotationFinishChain_Handler.class); + + private final KeyRotationSessionsDAO rotations = KeyRotationSessionsDAO.getInstance(); + private final KeyRotationCandidateBlocksDAO candidates = KeyRotationCandidateBlocksDAO.getInstance(); + private final BlocksDAO blocks = BlocksDAO.getInstance(); + private final shine.db.dao.CanonicalChainResolver canonicalChain = shine.db.dao.CanonicalChainResolver.getInstance(); + + @Override + public Net_Response handle(Net_Request baseReq, ConnectionContext ctx) { + Net_KeyRotationFinishChain_Request req = (Net_KeyRotationFinishChain_Request) baseReq; + if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) { + return NetExceptionResponseFactory.error(req, 401, "AUTH_REQUIRED", "Нужна авторизованная пользовательская сессия"); + } + String login = ctx.getLogin().trim(); + + KeyRotationSessionEntry initial; + try { + initial = rotations.getActiveByLogin(login); + } catch (Exception e) { + return NetExceptionResponseFactory.error(req, 500, "KEY_ROTATION_DB_ERROR", "Не удалось прочитать состояние смены ключей"); + } + if (initial == null) { + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_NOT_ACTIVE", "Активная ротация отсутствует"); + } + if (initial.getStatus() == KeyRotationStatus.CHAIN_READY) { + return KeyRotationApiSupport.response(req.getOp(), req.getRequestId(), initial); + } + if (initial.getStatus() != KeyRotationStatus.COPYING_CHAIN) { + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_NOT_COPYING", "Ротация не находится на этапе COPYING_CHAIN"); + } + + ReentrantLock lock = BlockchainLocks.lockFor(initial.getCandidateBlockchainName()); + lock.lock(); + try (Connection c = DbController.getInstance().getConnection()) { + KeyRotationSessionEntry session = rotations.getActiveByLogin(c, login); + if (session == null) { + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_NOT_ACTIVE", "Активная ротация отсутствует"); + } + if (session.getStatus() == KeyRotationStatus.CHAIN_READY) { + return KeyRotationApiSupport.response(req.getOp(), req.getRequestId(), session); + } + if (session.getStatus() != KeyRotationStatus.COPYING_CHAIN) { + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_NOT_COPYING", "Ротация больше не находится на этапе COPYING_CHAIN"); + } + + int expected = session.getProgressTotal(); + int stored = candidates.countStored(c, session.getId()); + int published = candidates.countPublished(c, session.getId()); + if (stored != expected) { + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_CHAIN_INCOMPLETE", + "Candidate-chain ещё не полностью загружена: " + stored + "/" + expected); + } + if (published != expected) { + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_CHAIN_NOT_PUBLISHED", + "Candidate-chain ещё не полностью опубликована в Arweave/Turbo: " + published + "/" + expected); + } + + List entries = candidates.listBySession(c, session.getId()); + String validationError = validateCompleteChain(c, session, entries); + if (validationError != null) { + try { rotations.recordError(session.getId(), validationError); } catch (Exception ignored) { } + return NetExceptionResponseFactory.error(req, 409, validationError, "Финальная проверка candidate-chain не пройдена"); + } + } catch (Exception e) { + return NetExceptionResponseFactory.error(req, 500, "KEY_ROTATION_FINISH_CHAIN_FAILED", "Не удалось завершить проверку candidate-chain"); + } finally { + lock.unlock(); + } + + try { + KeyRotationSessionEntry ready = rotations.transition( + initial.getId(), KeyRotationStatus.COPYING_CHAIN, KeyRotationStatus.CHAIN_READY); + rotations.clearError(initial.getId()); + return KeyRotationApiSupport.response(req.getOp(), req.getRequestId(), ready); + } catch (Exception transitionFailure) { + log.warn("KeyRotationFinishChain transition failed: login={}, sessionId={}", + login, initial.getId(), transitionFailure); + // Идемпотентность для параллельного FinishChain из другой сессии. + try { + KeyRotationSessionEntry now = rotations.getActiveByLogin(login); + if (now != null && now.getStatus() == KeyRotationStatus.CHAIN_READY) { + return KeyRotationApiSupport.response(req.getOp(), req.getRequestId(), now); + } + } catch (Exception ignored) { } + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_FINISH_CHAIN_RACE", "Состояние ротации изменилось во время FinishChain"); + } + } + + private String validateCompleteChain(Connection c, + KeyRotationSessionEntry session, + List entries) throws Exception { + if (session.getProgressTotal() != 1 || entries == null || entries.size() != 1) return "KEY_ROTATION_CHAIN_INCOMPLETE"; + KeyRotationCandidateBlockEntry stored=entries.get(0); + int expectedNumber=session.getForkFromBlock()+1; + if(stored.getBlockNumber()!=expectedNumber) return "KEY_ROTATION_CANDIDATE_GAP"; + if(stored.isArweavePublishPending() || stored.getArweavePublishedAtMs()==null) return "KEY_ROTATION_CHAIN_NOT_PUBLISHED"; + BchBlockEntry candidate; + try { candidate=new BchBlockEntry(stored.getBlockBytes()); candidate.body.check(); } catch(Exception e){ return "KEY_ROTATION_BAD_STORED_BLOCK"; } + if(candidate.blockNumber!=expectedNumber) return "KEY_ROTATION_BLOCK_NUMBER_MISMATCH"; + if(!Arrays.equals(candidate.getHash32(),stored.getBlockHash())) return "KEY_ROTATION_STORED_HASH_MISMATCH"; + if(!Arrays.equals(candidate.getDataItemId32(),stored.getDataItemId())) return "KEY_ROTATION_STORED_DATAITEM_MISMATCH"; + if(!candidate.getDataItem().hasTag(ShineProtocolTags.APP_TAG_NAME,ShineProtocolTags.APP_TAG_VALUE)) return "KEY_ROTATION_BAD_APP_TAG"; + String expectedTypeTag=expectedTypeTag(candidate), actualTypeTag=candidate.getDataItem().tagValue(ShineProtocolTags.TYPE_TAG_NAME); + if(expectedTypeTag!=null?!expectedTypeTag.equals(actualTypeTag):actualTypeTag!=null) return "KEY_ROTATION_BAD_TYPE_TAG"; + byte[] newKey=Base64.getDecoder().decode(session.getNewBlockchainKey()); + if(newKey.length!=32 || !BchCryptoVerifier.verifyBlock(candidate,newKey)) return "KEY_ROTATION_BAD_SIGNATURE"; + if(!Arrays.equals(candidate.prevHash32,session.getForkFromHash())) return "KEY_ROTATION_CHAIN_HASH_MISMATCH"; + byte[] expectedBack32=new byte[32]; + if(candidate.blockNumber>=32){ expectedBack32=canonicalChain.getHash(c,session.getSourceBlockchainName(),candidate.blockNumber-32); if(expectedBack32==null)return "KEY_ROTATION_BACK32_SOURCE_MISSING"; } + if(!Arrays.equals(candidate.back32Hash32,expectedBack32)) return "KEY_ROTATION_BACK32_HASH_MISMATCH"; + return validateAgainstRotation(c,session,candidate); + } + + private String validateAgainstRotation(Connection c, KeyRotationSessionEntry session, BchBlockEntry candidate) throws Exception { + if(candidate.blockNumber!=session.getForkFromBlock()+1) return "KEY_ROTATION_UNEXPECTED_BLOCK_NUMBER"; + if((candidate.type&0xFFFF)!=0 || (candidate.subType&0xFFFF)!=(MsgSubType.TECH_FORK&0xFFFF) || !(candidate.body instanceof ForkBody fork)) return "KEY_ROTATION_TECH_FORK_REQUIRED"; + if(!Arrays.equals(candidate.prevHash32,session.getForkFromHash())) return "KEY_ROTATION_TECH_FORK_PREV_HASH"; + BlockEntry forkSourceEntry=canonicalChain.getBlock(c,session.getSourceBlockchainName(),session.getForkFromBlock()); + BlockEntry tipSourceEntry=blocks.getByNumber(c,session.getSourceBlockchainName(),session.getSourceTipBlock()); + if(forkSourceEntry==null||tipSourceEntry==null)return "KEY_ROTATION_SOURCE_BLOCK_MISSING"; + BchBlockEntry forkSource=new BchBlockEntry(forkSourceEntry.getBlockBytes()), tipSource=new BchBlockEntry(tipSourceEntry.getBlockBytes()); + byte[] oldBlockchain=Base64.getDecoder().decode(session.getOldBlockchainKey()); + if(!Arrays.equals(fork.parentBlockchainKey32,oldBlockchain))return "KEY_ROTATION_TECH_FORK_PARENT_KEY"; + if(fork.forkPointBlockNumber!=session.getForkFromBlock())return "KEY_ROTATION_TECH_FORK_POINT"; + if(!Arrays.equals(fork.forkPointBlockHash32,session.getForkFromHash()))return "KEY_ROTATION_TECH_FORK_POINT_HASH"; + if(fork.forkPointTimestampMs!=Math.multiplyExact(forkSource.timestamp,1000L))return "KEY_ROTATION_TECH_FORK_POINT_TIME"; + if(fork.parentTipBlockNumber!=session.getSourceTipBlock())return "KEY_ROTATION_TECH_FORK_TIP"; + if(!Arrays.equals(fork.parentTipBlockHash32,session.getSourceTipHash()))return "KEY_ROTATION_TECH_FORK_TIP_HASH"; + if(fork.parentTipTimestampMs!=Math.multiplyExact(tipSource.timestamp,1000L))return "KEY_ROTATION_TECH_FORK_TIP_TIME"; + if(fork.discardedBlocksCount!=session.getSourceTipBlock()-session.getForkFromBlock())return "KEY_ROTATION_TECH_FORK_DISCARDED"; + if(fork.reasonCode!=session.getReasonCode())return "KEY_ROTATION_TECH_FORK_REASON"; + if(!normalizeComment(fork.comment).equals(normalizeComment(session.getComment())))return "KEY_ROTATION_TECH_FORK_COMMENT"; + return null; + } + + private static boolean isZero32(byte[] value) { + if (value == null || value.length != 32) return false; + for (byte b : value) if (b != 0) return false; + return true; + } + + private static String normalizeComment(String value) { + if (value == null) return ""; + return value.trim().replace("\r\n", "\n").replace('\r', '\n'); + } + private static String expectedTypeTag(BchBlockEntry block) { + int type = block.type & 0xffff; + return switch (type) { + case 0 -> "tech"; + case 3 -> "conn"; + case 4 -> "prof"; + default -> null; + }; + } + +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationRotatePda_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationRotatePda_Handler.java new file mode 100644 index 00000000..631d362f --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationRotatePda_Handler.java @@ -0,0 +1,91 @@ +package server.logic.ws_protocol.JSON.handlers.keyRotation; + +import server.logic.ws_protocol.JSON.ConnectionContext; +import server.logic.ws_protocol.JSON.entyties.Net_Request; +import server.logic.ws_protocol.JSON.entyties.Net_Response; +import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler; +import server.logic.ws_protocol.JSON.handlers.keyRotation.entyties.Net_KeyRotationRotatePda_Request; +import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory; +import shine.db.dao.CurrentUsersDAO; +import shine.db.dao.KeyRotationSessionsDAO; +import shine.db.entities.KeyRotationSessionEntry; +import shine.db.entities.KeyRotationStatus; + +/** + * Фиксирует уже отправленную клиентом Solana-транзакцию ротации PDA. + * Приватные ключи и подписанная транзакция через сервер не проходят: клиент передаёт только tx signature. + */ +public final class Net_KeyRotationRotatePda_Handler implements JsonMessageHandler { + private final KeyRotationSessionsDAO rotations = KeyRotationSessionsDAO.getInstance(); + + @Override + public Net_Response handle(Net_Request baseReq, ConnectionContext ctx) { + Net_KeyRotationRotatePda_Request req = (Net_KeyRotationRotatePda_Request) baseReq; + if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) { + return NetExceptionResponseFactory.error(req, 401, "AUTH_REQUIRED", "Нужна авторизованная пользовательская сессия"); + } + String login = ctx.getLogin().trim(); + + final String signature; + try { + signature = normalizeSolanaSignature(req.getPdaRotationSignature()); + } catch (IllegalArgumentException e) { + return NetExceptionResponseFactory.error(req, 400, "KEY_ROTATION_BAD_SOLANA_SIGNATURE", e.getMessage()); + } + + try { + KeyRotationSessionEntry current = rotations.getActiveByLogin(login); + if (current == null) { + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_NOT_ACTIVE", "Активная ротация отсутствует"); + } + + if (current.getStatus() == KeyRotationStatus.PDA_ROTATED) { + var fresh = CurrentUsersDAO.getInstance().getByLogin(login); + if (fresh != null) ctx.setCurrentUser(fresh); + return KeyRotationApiSupport.response(req.getOp(), req.getRequestId(), current); + } + + if (current.getStatus() == KeyRotationStatus.ROTATING_PDA) { + String stored = current.getPdaRotationSignature(); + if (stored != null && !stored.isBlank() && !stored.equals(signature)) { + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_PDA_SIGNATURE_CONFLICT", + "Для этой ротации уже сохранена другая Solana transaction signature"); + } + if (stored == null || stored.isBlank()) { + rotations.setPdaRotationSignature(current.getId(), signature); + } + } else if (current.getStatus() == KeyRotationStatus.CHAIN_READY) { + current = rotations.beginPdaRotation(current.getId(), signature); + } else { + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_NOT_CHAIN_READY", + "PDA можно ротировать только после CHAIN_READY"); + } + + // Solana sync мог увидеть новое PDA ещё до этого API-вызова. + KeyRotationSessionEntry confirmed = rotations.tryMarkPdaRotatedFromCurrentState(current.getId()); + rotations.clearError(current.getId()); + KeyRotationSessionEntry result = confirmed != null ? confirmed : rotations.getById(current.getId()); + if (result != null && result.getStatus() == KeyRotationStatus.PDA_ROTATED) { + var fresh = CurrentUsersDAO.getInstance().getByLogin(login); + if (fresh != null) ctx.setCurrentUser(fresh); + } + return KeyRotationApiSupport.response(req.getOp(), req.getRequestId(), result); + } catch (Exception e) { + return NetExceptionResponseFactory.error(req, 500, "KEY_ROTATION_ROTATE_PDA_FAILED", + "Не удалось зафиксировать Solana-ротацию PDA"); + } + } + + private static String normalizeSolanaSignature(String raw) { + if (raw == null || raw.isBlank()) throw new IllegalArgumentException("pdaRotationSignature обязательна"); + String s = raw.trim(); + if (s.length() > 128) throw new IllegalArgumentException("Слишком длинная Solana transaction signature"); + final String alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"; + for (int i = 0; i < s.length(); i++) { + if (alphabet.indexOf(s.charAt(i)) < 0) { + throw new IllegalArgumentException("Solana transaction signature должна быть Base58"); + } + } + return s; + } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationStart_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationStart_Handler.java new file mode 100644 index 00000000..5b840bf7 --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationStart_Handler.java @@ -0,0 +1,224 @@ +package server.logic.ws_protocol.JSON.handlers.keyRotation; + +import server.logic.ws_protocol.JSON.ConnectionContext; +import server.logic.ws_protocol.JSON.entyties.Net_Request; +import server.logic.ws_protocol.JSON.entyties.Net_Response; +import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler; +import server.logic.ws_protocol.JSON.handlers.blockchain.Net_AddBlock_Handler_utils.BlockchainLocks; +import server.logic.ws_protocol.JSON.handlers.auth.SessionRevocationSupport; +import server.logic.ws_protocol.JSON.handlers.keyRotation.entyties.Net_KeyRotationStart_Request; +import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory; +import shine.db.DbController; +import shine.db.dao.BlockchainStateDAO; +import shine.db.dao.BlocksDAO; +import shine.db.dao.KeyRotationSessionsDAO; +import shine.db.entities.BlockEntry; +import shine.db.entities.BlockchainStateEntry; +import shine.db.entities.KeyRotationSessionEntry; +import shine.db.entities.KeyRotationStatus; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.util.List; +import java.util.concurrent.locks.ReentrantLock; + +/** + * Создаёт серверную ротацию сразу в COPYING_CHAIN. + * До этого момента всё заполнение формы остаётся только локальным UI-состоянием. + */ +public final class Net_KeyRotationStart_Handler implements JsonMessageHandler { + private final KeyRotationSessionsDAO rotations = KeyRotationSessionsDAO.getInstance(); + private final BlockchainStateDAO states = BlockchainStateDAO.getInstance(); + private final BlocksDAO blocks = BlocksDAO.getInstance(); + private final shine.db.dao.CanonicalChainResolver canonicalChain = shine.db.dao.CanonicalChainResolver.getInstance(); + + @Override + public Net_Response handle(Net_Request baseReq, ConnectionContext ctx) { + Net_KeyRotationStart_Request req = (Net_KeyRotationStart_Request) baseReq; + if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) { + return NetExceptionResponseFactory.error(req, 401, "AUTH_REQUIRED", "Нужна авторизованная пользовательская сессия"); + } + String login = ctx.getLogin().trim(); + String currentSessionId = ctx.getSessionId() == null ? "" : ctx.getSessionId().trim(); + if (currentSessionId.isEmpty()) { + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_SESSION_STALE", + "В текущем соединении отсутствует sessionId; войдите заново"); + } + String ctxBlockchainName = ctx.getCurrentUser() != null ? ctx.getCurrentUser().getBlockchainName() : null; + if (ctxBlockchainName == null || ctxBlockchainName.isBlank()) { + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_SESSION_STALE", + "В сессии отсутствует актуальный blockchainName; войдите заново"); + } + + final String newRoot; + final String newBlockchain; + final String newClient; + final byte[] requestedForkHash; + try { + newRoot = KeyRotationApiSupport.normalizePublicKey32(req.getNewRootKey()); + newBlockchain = KeyRotationApiSupport.normalizePublicKey32(req.getNewBlockchainKey()); + newClient = KeyRotationApiSupport.normalizePublicKey32(req.getNewClientKey()); + requestedForkHash = KeyRotationApiSupport.parseHash32(req.getForkFromHash()); + } catch (IllegalArgumentException e) { + return NetExceptionResponseFactory.error(req, 400, "KEY_ROTATION_BAD_FIELDS", e.getMessage()); + } + if (req.getReasonCode() < 1 || req.getReasonCode() > 4) { + return NetExceptionResponseFactory.error(req, 400, "KEY_ROTATION_BAD_REASON", "reasonCode должен быть 1..4"); + } + String comment = req.getComment() == null ? "" : req.getComment(); + if (comment.getBytes(java.nio.charset.StandardCharsets.UTF_8).length > 1024) { + return NetExceptionResponseFactory.error(req, 400, "KEY_ROTATION_COMMENT_TOO_LONG", "Комментарий должен быть не длиннее 1024 UTF-8 байт"); + } + if (req.getForkFromBlock() < 0) { + return NetExceptionResponseFactory.error(req, 400, "KEY_ROTATION_BAD_FORK_POINT", "forkFromBlock должен быть >= 0"); + } + + ReentrantLock lock = BlockchainLocks.lockFor(ctxBlockchainName); + lock.lock(); + try (Connection c = DbController.getInstance().getConnection()) { + boolean oldAutoCommit = c.getAutoCommit(); + c.setAutoCommit(false); + try { + PdaSnapshot pda = loadPdaForUpdate(c, login); + if (pda == null) { + c.rollback(); + return NetExceptionResponseFactory.error(req, 404, "KEY_ROTATION_USER_NOT_FOUND", "Пользователь не найден в текущем Solana PDA state"); + } + if (!KeyRotationStatus.NONE.name().equals(pda.rotationStatus)) { + KeyRotationSessionEntry active = rotations.getActiveByLogin(c, login); + c.rollback(); + if (active != null + && sameStartRequest(active, newRoot, newBlockchain, newClient, + req.getForkFromBlock(), requestedForkHash, req.getReasonCode(), comment)) { + return KeyRotationApiSupport.response(req.getOp(), req.getRequestId(), active); + } + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_ALREADY_ACTIVE", "Смена ключей уже выполняется с другими параметрами"); + } + if (!ctxBlockchainName.equals(pda.blockchainName)) { + c.rollback(); + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_SESSION_STALE", + "Активный blockchain изменился; обновите сессию и повторите"); + } + + String oldRoot = KeyRotationApiSupport.normalizePublicKey32(pda.rootKey); + String oldBlockchain = KeyRotationApiSupport.normalizePublicKey32(pda.blockchainKey); + String oldClient = KeyRotationApiSupport.normalizePublicKey32(pda.clientKey); + try { + KeyRotationApiSupport.requireKeysChangedAndDistinct( + oldRoot, oldBlockchain, oldClient, newRoot, newBlockchain, newClient); + } catch (IllegalArgumentException e) { + c.rollback(); + return NetExceptionResponseFactory.error(req, 400, "KEY_ROTATION_BAD_NEW_KEYS", e.getMessage()); + } + + BlockchainStateEntry state = states.getByBlockchainName(c, pda.blockchainName); + if (state == null || state.getLastBlockHash() == null || state.getLastBlockHash().length != 32) { + c.rollback(); + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_CHAIN_STATE_MISSING", "Не найдено корректное текущее состояние блокчейна"); + } + if (req.getForkFromBlock() > state.getLastBlockNumber()) { + c.rollback(); + return NetExceptionResponseFactory.error(req, 400, "KEY_ROTATION_BAD_FORK_POINT", "Точка fork находится после текущего tip"); + } + BlockEntry forkBlock = canonicalChain.getBlock(c, pda.blockchainName, req.getForkFromBlock()); + if (forkBlock == null || forkBlock.getBlockHash() == null || forkBlock.getBlockHash().length != 32) { + c.rollback(); + return NetExceptionResponseFactory.error(req, 404, "KEY_ROTATION_FORK_BLOCK_NOT_FOUND", "Выбранный блок не найден на сервере"); + } + if (!KeyRotationApiSupport.hashesEqual(forkBlock.getBlockHash(), requestedForkHash)) { + c.rollback(); + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_FORK_HASH_MISMATCH", "Хэш выбранного блока не совпадает с сервером"); + } + + final String candidateName; + try { + candidateName = KeyRotationApiSupport.nextBlockchainName(login, pda.blockchainName); + } catch (IllegalArgumentException e) { + c.rollback(); + return NetExceptionResponseFactory.error(req, 400, "KEY_ROTATION_BAD_BLOCKCHAIN_NAME", e.getMessage()); + } + + KeyRotationSessionEntry entry = new KeyRotationSessionEntry(); + entry.setLogin(login); + entry.setSourceBlockchainName(pda.blockchainName); + entry.setCandidateBlockchainName(candidateName); + entry.setOldRootKey(oldRoot); + entry.setOldBlockchainKey(oldBlockchain); + entry.setOldClientKey(oldClient); + entry.setNewRootKey(newRoot); + entry.setNewBlockchainKey(newBlockchain); + entry.setNewClientKey(newClient); + entry.setForkFromBlock(req.getForkFromBlock()); + entry.setForkFromHash(requestedForkHash); + entry.setSourceTipBlock(state.getLastBlockNumber()); + entry.setSourceTipHash(state.getLastBlockHash()); + entry.setReasonCode(req.getReasonCode()); + entry.setComment(comment); + entry.setProgressCurrent(0); + entry.setProgressTotal(1); // segmented fork publishes only TECH_FORK + + KeyRotationSessionEntry created = rotations.createCopyingSession(c, entry); + List revokedSessionIds = SessionRevocationSupport + .deleteOtherSessions(c, login, currentSessionId); + c.commit(); + SessionRevocationSupport.revokeConnections( + revokedSessionIds, + "key_rotation_started", + "Session closed because key rotation started" + ); + return KeyRotationApiSupport.response(req.getOp(), req.getRequestId(), created); + } catch (ArithmeticException e) { + c.rollback(); + return NetExceptionResponseFactory.error(req, 400, "KEY_ROTATION_BAD_FORK_POINT", "Слишком большой номер блока"); + } catch (Exception e) { + c.rollback(); + return NetExceptionResponseFactory.error(req, 500, "KEY_ROTATION_START_FAILED", "Не удалось запустить смену ключей"); + } finally { + c.setAutoCommit(oldAutoCommit); + } + } catch (Exception e) { + return NetExceptionResponseFactory.error(req, 500, "KEY_ROTATION_START_FAILED", "Не удалось открыть транзакцию смены ключей"); + } finally { + lock.unlock(); + } + } + + + private static boolean sameStartRequest(KeyRotationSessionEntry active, + String newRoot, String newBlockchain, String newClient, + int forkFromBlock, byte[] forkFromHash, short reasonCode, String comment) { + return active != null + && java.util.Objects.equals(active.getNewRootKey(), newRoot) + && java.util.Objects.equals(active.getNewBlockchainKey(), newBlockchain) + && java.util.Objects.equals(active.getNewClientKey(), newClient) + && active.getForkFromBlock() == forkFromBlock + && java.util.Arrays.equals(active.getForkFromHash(), forkFromHash) + && active.getReasonCode() == reasonCode + && java.util.Objects.equals(active.getComment() == null ? "" : active.getComment(), comment == null ? "" : comment); + } + + private static PdaSnapshot loadPdaForUpdate(Connection c, String login) throws Exception { + try (PreparedStatement ps = c.prepareStatement(""" + SELECT root_key, blockchain_key, client_key, blockchain_name, rotation_status + FROM solana_user_pda_current + WHERE normalized_login = LOWER(BTRIM(?)) + FOR UPDATE + """)) { + ps.setString(1, login); + try (ResultSet rs = ps.executeQuery()) { + if (!rs.next()) return null; + return new PdaSnapshot( + rs.getString("root_key"), + rs.getString("blockchain_key"), + rs.getString("client_key"), + rs.getString("blockchain_name"), + rs.getString("rotation_status") + ); + } + } + } + + private record PdaSnapshot(String rootKey, String blockchainKey, String clientKey, + String blockchainName, String rotationStatus) { } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationStatus_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationStatus_Handler.java new file mode 100644 index 00000000..901249ea --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/Net_KeyRotationStatus_Handler.java @@ -0,0 +1,50 @@ +package server.logic.ws_protocol.JSON.handlers.keyRotation; + +import server.logic.ws_protocol.JSON.ConnectionContext; +import server.logic.ws_protocol.JSON.entyties.Net_Request; +import server.logic.ws_protocol.JSON.entyties.Net_Response; +import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler; +import server.logic.ws_protocol.JSON.handlers.keyRotation.entyties.Net_KeyRotationStatus_Request; +import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory; +import shine.db.dao.CurrentUsersDAO; +import shine.db.dao.KeyRotationSessionsDAO; +import shine.db.entities.KeyRotationSessionEntry; +import shine.db.entities.KeyRotationStatus; + +public final class Net_KeyRotationStatus_Handler implements JsonMessageHandler { + private final KeyRotationSessionsDAO rotations = KeyRotationSessionsDAO.getInstance(); + + @Override + public Net_Response handle(Net_Request baseReq, ConnectionContext ctx) { + Net_KeyRotationStatus_Request req = (Net_KeyRotationStatus_Request) baseReq; + if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) { + return NetExceptionResponseFactory.error(req, 401, "AUTH_REQUIRED", "Нужна авторизованная пользовательская сессия"); + } + try { + String login = ctx.getLogin().trim(); + KeyRotationSessionEntry current = rotations.getActiveByLogin(login); + if (current != null && isPdaAlreadyRotated(current.getStatus())) { + refreshCurrentUser(ctx, login); + } + return KeyRotationApiSupport.response(req.getOp(), req.getRequestId(), current); + } catch (Exception e) { + return NetExceptionResponseFactory.error(req, 500, "KEY_ROTATION_STATUS_FAILED", + "Не удалось прочитать состояние смены ключей"); + } + } + + + private static boolean isPdaAlreadyRotated(KeyRotationStatus status) { + return status == KeyRotationStatus.PDA_ROTATED + || status == KeyRotationStatus.REBUILDING_SERVER + || status == KeyRotationStatus.WALLET_MIGRATION + || status == KeyRotationStatus.MESSAGE_MIGRATION + || status == KeyRotationStatus.FINALIZING + || status == KeyRotationStatus.COMPLETE; + } + + private static void refreshCurrentUser(ConnectionContext ctx, String login) throws Exception { + var fresh = CurrentUsersDAO.getInstance().getByLogin(login); + if (fresh != null) ctx.setCurrentUser(fresh); + } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationAbort_Request.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationAbort_Request.java new file mode 100644 index 00000000..134828ec --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationAbort_Request.java @@ -0,0 +1,7 @@ +package server.logic.ws_protocol.JSON.handlers.keyRotation.entyties; + +import server.logic.ws_protocol.JSON.entyties.Net_Request; + +/** Прервать ротацию до отправки Solana-транзакции. */ +public final class Net_KeyRotationAbort_Request extends Net_Request { +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationAddBlock_Request.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationAddBlock_Request.java new file mode 100644 index 00000000..dec03050 --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationAddBlock_Request.java @@ -0,0 +1,17 @@ +package server.logic.ws_protocol.JSON.handlers.keyRotation.entyties; + +import server.logic.ws_protocol.JSON.entyties.Net_Request; + +/** Один подписанный новым blockchain key DataItem будущего fork. */ +public final class Net_KeyRotationAddBlock_Request extends Net_Request { + private int blockNumber; + private String prevBlockHash; + private String blockBytesB64; + + public int getBlockNumber() { return blockNumber; } + public void setBlockNumber(int blockNumber) { this.blockNumber = blockNumber; } + public String getPrevBlockHash() { return prevBlockHash; } + public void setPrevBlockHash(String prevBlockHash) { this.prevBlockHash = prevBlockHash; } + public String getBlockBytesB64() { return blockBytesB64; } + public void setBlockBytesB64(String blockBytesB64) { this.blockBytesB64 = blockBytesB64; } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationContinue_Request.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationContinue_Request.java new file mode 100644 index 00000000..bb1d2b9a --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationContinue_Request.java @@ -0,0 +1,11 @@ +package server.logic.ws_protocol.JSON.handlers.keyRotation.entyties; + +import server.logic.ws_protocol.JSON.entyties.Net_Request; + +/** Продолжить post-PDA этап после фактической клиентской работы. */ +public final class Net_KeyRotationContinue_Request extends Net_Request { + private String walletMigrationStatus; + + public String getWalletMigrationStatus() { return walletMigrationStatus; } + public void setWalletMigrationStatus(String walletMigrationStatus) { this.walletMigrationStatus = walletMigrationStatus; } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationFinishChain_Request.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationFinishChain_Request.java new file mode 100644 index 00000000..01fabbf9 --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationFinishChain_Request.java @@ -0,0 +1,7 @@ +package server.logic.ws_protocol.JSON.handlers.keyRotation.entyties; + +import server.logic.ws_protocol.JSON.entyties.Net_Request; + +/** Финальная проверка полностью опубликованной candidate-chain. */ +public final class Net_KeyRotationFinishChain_Request extends Net_Request { +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationRotatePda_Request.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationRotatePda_Request.java new file mode 100644 index 00000000..20c36be5 --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationRotatePda_Request.java @@ -0,0 +1,14 @@ +package server.logic.ws_protocol.JSON.handlers.keyRotation.entyties; + +import server.logic.ws_protocol.JSON.entyties.Net_Request; + +/** + * Клиент уже локально подписал и отправил Solana-транзакцию ротации PDA. + * Серверу передаётся только публичная Solana transaction signature для аудита/возобновления. + */ +public final class Net_KeyRotationRotatePda_Request extends Net_Request { + private String pdaRotationSignature; + + public String getPdaRotationSignature() { return pdaRotationSignature; } + public void setPdaRotationSignature(String pdaRotationSignature) { this.pdaRotationSignature = pdaRotationSignature; } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationStart_Request.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationStart_Request.java new file mode 100644 index 00000000..8677843b --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationStart_Request.java @@ -0,0 +1,32 @@ +package server.logic.ws_protocol.JSON.handlers.keyRotation.entyties; + +import server.logic.ws_protocol.JSON.entyties.Net_Request; + +/** + * Запуск смены ключей. Старые ключи сервер берёт из текущего Solana PDA; + * клиент передаёт только новые публичные ключи и выбранную точку fork. + */ +public final class Net_KeyRotationStart_Request extends Net_Request { + private String newRootKey; + private String newBlockchainKey; + private String newClientKey; + private int forkFromBlock; + private String forkFromHash; + private short reasonCode; + private String comment; + + public String getNewRootKey() { return newRootKey; } + public void setNewRootKey(String newRootKey) { this.newRootKey = newRootKey; } + public String getNewBlockchainKey() { return newBlockchainKey; } + public void setNewBlockchainKey(String newBlockchainKey) { this.newBlockchainKey = newBlockchainKey; } + public String getNewClientKey() { return newClientKey; } + public void setNewClientKey(String newClientKey) { this.newClientKey = newClientKey; } + public int getForkFromBlock() { return forkFromBlock; } + public void setForkFromBlock(int forkFromBlock) { this.forkFromBlock = forkFromBlock; } + public String getForkFromHash() { return forkFromHash; } + public void setForkFromHash(String forkFromHash) { this.forkFromHash = forkFromHash; } + public short getReasonCode() { return reasonCode; } + public void setReasonCode(short reasonCode) { this.reasonCode = reasonCode; } + public String getComment() { return comment; } + public void setComment(String comment) { this.comment = comment; } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationState_Response.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationState_Response.java new file mode 100644 index 00000000..fc8d00d5 --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationState_Response.java @@ -0,0 +1,83 @@ +package server.logic.ws_protocol.JSON.handlers.keyRotation.entyties; + +import server.logic.ws_protocol.JSON.entyties.Net_Response; + +/** Публичное состояние текущей/только что созданной ротации. */ +public final class Net_KeyRotationState_Response extends Net_Response { + private Long rotationSessionId; + private String rotationStatus; + private String sourceBlockchainName; + private String candidateBlockchainName; + private String oldRootKey; + private String oldBlockchainKey; + private String oldClientKey; + private String newRootKey; + private String newBlockchainKey; + private String newClientKey; + private Integer forkFromBlock; + private String forkFromHash; + private Integer sourceTipBlock; + private String sourceTipHash; + private Short reasonCode; + private String comment; + private Integer progressCurrent; + private Integer progressTotal; + private String pdaRotationSignature; + private String walletMigrationStatus; + private String messageMigrationStatus; + private String lastError; + private Integer retryCount; + private Long createdAtMs; + private Long updatedAtMs; + + public Long getRotationSessionId() { return rotationSessionId; } + public void setRotationSessionId(Long rotationSessionId) { this.rotationSessionId = rotationSessionId; } + public String getRotationStatus() { return rotationStatus; } + public void setRotationStatus(String rotationStatus) { this.rotationStatus = rotationStatus; } + public String getSourceBlockchainName() { return sourceBlockchainName; } + public void setSourceBlockchainName(String sourceBlockchainName) { this.sourceBlockchainName = sourceBlockchainName; } + public String getCandidateBlockchainName() { return candidateBlockchainName; } + public void setCandidateBlockchainName(String candidateBlockchainName) { this.candidateBlockchainName = candidateBlockchainName; } + public String getOldRootKey() { return oldRootKey; } + public void setOldRootKey(String oldRootKey) { this.oldRootKey = oldRootKey; } + public String getOldBlockchainKey() { return oldBlockchainKey; } + public void setOldBlockchainKey(String oldBlockchainKey) { this.oldBlockchainKey = oldBlockchainKey; } + public String getOldClientKey() { return oldClientKey; } + public void setOldClientKey(String oldClientKey) { this.oldClientKey = oldClientKey; } + public String getNewRootKey() { return newRootKey; } + public void setNewRootKey(String newRootKey) { this.newRootKey = newRootKey; } + public String getNewBlockchainKey() { return newBlockchainKey; } + public void setNewBlockchainKey(String newBlockchainKey) { this.newBlockchainKey = newBlockchainKey; } + public String getNewClientKey() { return newClientKey; } + public void setNewClientKey(String newClientKey) { this.newClientKey = newClientKey; } + public Integer getForkFromBlock() { return forkFromBlock; } + public void setForkFromBlock(Integer forkFromBlock) { this.forkFromBlock = forkFromBlock; } + public String getForkFromHash() { return forkFromHash; } + public void setForkFromHash(String forkFromHash) { this.forkFromHash = forkFromHash; } + public Integer getSourceTipBlock() { return sourceTipBlock; } + public void setSourceTipBlock(Integer sourceTipBlock) { this.sourceTipBlock = sourceTipBlock; } + public String getSourceTipHash() { return sourceTipHash; } + public void setSourceTipHash(String sourceTipHash) { this.sourceTipHash = sourceTipHash; } + public Short getReasonCode() { return reasonCode; } + public void setReasonCode(Short reasonCode) { this.reasonCode = reasonCode; } + public String getComment() { return comment; } + public void setComment(String comment) { this.comment = comment; } + public Integer getProgressCurrent() { return progressCurrent; } + public void setProgressCurrent(Integer progressCurrent) { this.progressCurrent = progressCurrent; } + public Integer getProgressTotal() { return progressTotal; } + public void setProgressTotal(Integer progressTotal) { this.progressTotal = progressTotal; } + public String getPdaRotationSignature() { return pdaRotationSignature; } + public void setPdaRotationSignature(String pdaRotationSignature) { this.pdaRotationSignature = pdaRotationSignature; } + public String getWalletMigrationStatus() { return walletMigrationStatus; } + public void setWalletMigrationStatus(String walletMigrationStatus) { this.walletMigrationStatus = walletMigrationStatus; } + public String getMessageMigrationStatus() { return messageMigrationStatus; } + public void setMessageMigrationStatus(String messageMigrationStatus) { this.messageMigrationStatus = messageMigrationStatus; } + public String getLastError() { return lastError; } + public void setLastError(String lastError) { this.lastError = lastError; } + public Integer getRetryCount() { return retryCount; } + public void setRetryCount(Integer retryCount) { this.retryCount = retryCount; } + public Long getCreatedAtMs() { return createdAtMs; } + public void setCreatedAtMs(Long createdAtMs) { this.createdAtMs = createdAtMs; } + public Long getUpdatedAtMs() { return updatedAtMs; } + public void setUpdatedAtMs(Long updatedAtMs) { this.updatedAtMs = updatedAtMs; } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationStatus_Request.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationStatus_Request.java new file mode 100644 index 00000000..d5eb01bb --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/keyRotation/entyties/Net_KeyRotationStatus_Request.java @@ -0,0 +1,7 @@ +package server.logic.ws_protocol.JSON.handlers.keyRotation.entyties; + +import server.logic.ws_protocol.JSON.entyties.Net_Request; + +/** Запрос текущего состояния ротации авторизованного пользователя. */ +public final class Net_KeyRotationStatus_Request extends Net_Request { +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/profile/AvatarValueParser.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/profile/AvatarValueParser.java new file mode 100644 index 00000000..6277da4d --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/profile/AvatarValueParser.java @@ -0,0 +1,57 @@ +package server.logic.ws_protocol.JSON.handlers.profile; + +import java.util.HashMap; +import java.util.Map; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public final class AvatarValueParser { + private static final Pattern NEW_TAG = Pattern.compile("^<(?:SHiNE|S):(?:ava|avatar);([^>]*)>$"); + private static final Pattern LEGACY_AR = Pattern.compile("AR:([A-Za-z0-9_-]{43})"); + private static final Pattern LEGACY_SHA = Pattern.compile("SHA256:([A-Fa-f0-9]{64})"); + private static final Pattern AR = Pattern.compile("^[A-Za-z0-9_-]{43}$"); + private static final Pattern SHA = Pattern.compile("^[A-Fa-f0-9]{64}$"); + + private AvatarValueParser() {} + + public static Parsed parse(String rawValue) { + String raw = String.valueOf(rawValue == null ? "" : rawValue).trim(); + if (raw.isEmpty()) return new Parsed("", "", 0L, false); + + Matcher tag = NEW_TAG.matcher(raw); + if (tag.matches()) { + Map fields = fields(tag.group(1)); + if (!"1".equals(fields.get("v"))) return new Parsed("", "", 0L, false); + String ar = String.valueOf(fields.getOrDefault("ar", "")).trim(); + String sha = String.valueOf(fields.getOrDefault("sha256", "")).trim().toLowerCase(); + String sizeRaw = String.valueOf(fields.containsKey("sz") ? fields.get("sz") : fields.getOrDefault("size", "")).trim(); + if (!ar.isEmpty() && !AR.matcher(ar).matches()) return new Parsed("", "", 0L, false); + if (!SHA.matcher(sha).matches()) return new Parsed("", "", 0L, false); + long size; + try { size = Long.parseLong(sizeRaw); } catch (Exception e) { return new Parsed("", "", 0L, false); } + if (size <= 0L) return new Parsed("", "", 0L, false); + return new Parsed(ar, sha, size, true); + } + + Matcher arMatcher = LEGACY_AR.matcher(raw); + Matcher shaMatcher = LEGACY_SHA.matcher(raw); + String ar = arMatcher.find() ? arMatcher.group(1) : ""; + String sha = shaMatcher.find() ? shaMatcher.group(1).toLowerCase() : ""; + if (!AR.matcher(ar).matches()) return new Parsed("", "", 0L, false); + return new Parsed(ar, SHA.matcher(sha).matches() ? sha : "", 0L, true); + } + + private static Map fields(String raw) { + Map out = new HashMap<>(); + for (String part : String.valueOf(raw == null ? "" : raw).split(";")) { + int eq = part.indexOf('='); + if (eq <= 0) continue; + String key = part.substring(0, eq).trim(); + String value = part.substring(eq + 1).trim(); + if (!key.isEmpty()) out.put(key, value); + } + return out; + } + + public record Parsed(String ar, String sha256Hex, long size, boolean ok) {} +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/profile/Net_ListUserProfileChannels_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/profile/Net_ListUserProfileChannels_Handler.java index 4f14722b..506a8c8d 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/profile/Net_ListUserProfileChannels_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/profile/Net_ListUserProfileChannels_Handler.java @@ -1,3 +1,3 @@ package server.logic.ws_protocol.JSON.handlers.profile; import server.logic.ws_protocol.JSON.*;import server.logic.ws_protocol.JSON.entyties.*;import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler;import server.logic.ws_protocol.JSON.handlers.profile.entyties.*;import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory;import server.logic.ws_protocol.WireCodes;import shine.db.dao.UserProfileStateDAO;import java.sql.*;import java.util.*; -public class Net_ListUserProfileChannels_Handler implements JsonMessageHandler {public Net_Response handle(Net_Request base,ConnectionContext ctx)throws Exception{var req=(Net_ListUserProfileChannels_Request)base;if(req.getLogin()==null||req.getLogin().isBlank())return NetExceptionResponseFactory.error(req,400,"BAD_FIELDS","login required");try(Connection c=shine.db.DbController.getInstance().getConnection()){var rows=UserProfileStateDAO.getInstance().listPublicChannels(c,req.getLogin(),req.getMode(),req.getLimit()==null?100:req.getLimit(),req.getOffset()==null?0:req.getOffset());var resp=new Net_ListUserProfileChannels_Response();resp.setOp(req.getOp());resp.setRequestId(req.getRequestId());resp.setStatus(WireCodes.Status.OK);resp.setLogin(req.getLogin());resp.setMode(req.getMode());List items=new ArrayList<>();for(var r:rows){var i=new Net_ListUserProfileChannels_Response.ChannelItem();i.setOwnerLogin(r.ownerLogin());i.setSlug(r.slug());i.setDisplayName(r.displayName());i.setAvatarAr(r.avatarAr());i.setOwnerBlockchainName(r.ownerBlockchainName());i.setRootBlockNumber(r.rootBlockNumber());i.setRootBlockHashHex(r.rootBlockHashHex());items.add(i);}resp.setChannels(items);return resp;}}} +public class Net_ListUserProfileChannels_Handler implements JsonMessageHandler {public Net_Response handle(Net_Request base,ConnectionContext ctx)throws Exception{var req=(Net_ListUserProfileChannels_Request)base;if(req.getLogin()==null||req.getLogin().isBlank())return NetExceptionResponseFactory.error(req,400,"BAD_FIELDS","login required");try(Connection c=shine.db.DbController.getInstance().getConnection()){var rows=UserProfileStateDAO.getInstance().listPublicChannels(c,req.getLogin(),req.getMode(),Boolean.TRUE.equals(req.getIncludeDeleted()),req.getLimit()==null?100:req.getLimit(),req.getOffset()==null?0:req.getOffset());var resp=new Net_ListUserProfileChannels_Response();resp.setOp(req.getOp());resp.setRequestId(req.getRequestId());resp.setStatus(WireCodes.Status.OK);resp.setLogin(req.getLogin());resp.setMode(req.getMode());List items=new ArrayList<>();for(var r:rows){var i=new Net_ListUserProfileChannels_Response.ChannelItem();i.setOwnerLogin(r.ownerLogin());i.setSlug(r.slug());i.setDisplayName(r.displayName());i.setAvatarAr(r.avatarAr());i.setAvatarSha256(r.avatarSha256());i.setOwnerBlockchainName(r.ownerBlockchainName());i.setRootBlockNumber(r.rootBlockNumber());i.setRootBlockHashHex(r.rootBlockHashHex());i.setDeleted(r.deleted());i.setDeletedAtMs(r.deletedAtMs());i.setDeletedBlockNumber(r.deletedBlockNumber());items.add(i);}resp.setChannels(items);return resp;}}} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/profile/entyties/Net_ListUserProfileChannels_Request.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/profile/entyties/Net_ListUserProfileChannels_Request.java index c466c405..81516117 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/profile/entyties/Net_ListUserProfileChannels_Request.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/profile/entyties/Net_ListUserProfileChannels_Request.java @@ -1,3 +1,3 @@ package server.logic.ws_protocol.JSON.handlers.profile.entyties; import server.logic.ws_protocol.JSON.entyties.Net_Request; -public class Net_ListUserProfileChannels_Request extends Net_Request {private String login,mode;private Integer limit,offset;public String getLogin(){return login;}public void setLogin(String v){login=v;}public String getMode(){return mode;}public void setMode(String v){mode=v;}public Integer getLimit(){return limit;}public void setLimit(Integer v){limit=v;}public Integer getOffset(){return offset;}public void setOffset(Integer v){offset=v;}} +public class Net_ListUserProfileChannels_Request extends Net_Request {private String login,mode;private Integer limit,offset;private Boolean includeDeleted;public String getLogin(){return login;}public void setLogin(String v){login=v;}public String getMode(){return mode;}public void setMode(String v){mode=v;}public Integer getLimit(){return limit;}public void setLimit(Integer v){limit=v;}public Integer getOffset(){return offset;}public void setOffset(Integer v){offset=v;}public Boolean getIncludeDeleted(){return includeDeleted;}public void setIncludeDeleted(Boolean v){includeDeleted=v;}} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/profile/entyties/Net_ListUserProfileChannels_Response.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/profile/entyties/Net_ListUserProfileChannels_Response.java index f90d99aa..da0a0c41 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/profile/entyties/Net_ListUserProfileChannels_Response.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/profile/entyties/Net_ListUserProfileChannels_Response.java @@ -1,3 +1,3 @@ package server.logic.ws_protocol.JSON.handlers.profile.entyties; import server.logic.ws_protocol.JSON.entyties.Net_Response;import java.util.*; -public class Net_ListUserProfileChannels_Response extends Net_Response {private String login,mode;private List channels=new ArrayList<>();public String getLogin(){return login;}public void setLogin(String v){login=v;}public String getMode(){return mode;}public void setMode(String v){mode=v;}public List getChannels(){return channels;}public void setChannels(List v){channels=v;}public static class ChannelItem{private String ownerLogin,slug,displayName,avatarAr,ownerBlockchainName,rootBlockHashHex;private int rootBlockNumber;public String getOwnerLogin(){return ownerLogin;}public void setOwnerLogin(String v){ownerLogin=v;}public String getSlug(){return slug;}public void setSlug(String v){slug=v;}public String getDisplayName(){return displayName;}public void setDisplayName(String v){displayName=v;}public String getAvatarAr(){return avatarAr;}public void setAvatarAr(String v){avatarAr=v;}public String getOwnerBlockchainName(){return ownerBlockchainName;}public void setOwnerBlockchainName(String v){ownerBlockchainName=v;}public int getRootBlockNumber(){return rootBlockNumber;}public void setRootBlockNumber(int v){rootBlockNumber=v;}public String getRootBlockHashHex(){return rootBlockHashHex;}public void setRootBlockHashHex(String v){rootBlockHashHex=v;}}} +public class Net_ListUserProfileChannels_Response extends Net_Response {private String login,mode;private List channels=new ArrayList<>();public String getLogin(){return login;}public void setLogin(String v){login=v;}public String getMode(){return mode;}public void setMode(String v){mode=v;}public List getChannels(){return channels;}public void setChannels(List v){channels=v;}public static class ChannelItem{private String ownerLogin,slug,displayName,avatarAr,avatarSha256,ownerBlockchainName,rootBlockHashHex;private int rootBlockNumber;private boolean deleted;private long deletedAtMs;private Integer deletedBlockNumber;public String getOwnerLogin(){return ownerLogin;}public void setOwnerLogin(String v){ownerLogin=v;}public String getSlug(){return slug;}public void setSlug(String v){slug=v;}public String getDisplayName(){return displayName;}public void setDisplayName(String v){displayName=v;}public String getAvatarAr(){return avatarAr;}public void setAvatarAr(String v){avatarAr=v;}public String getAvatarSha256(){return avatarSha256;}public void setAvatarSha256(String v){avatarSha256=v;}public String getOwnerBlockchainName(){return ownerBlockchainName;}public void setOwnerBlockchainName(String v){ownerBlockchainName=v;}public int getRootBlockNumber(){return rootBlockNumber;}public void setRootBlockNumber(int v){rootBlockNumber=v;}public String getRootBlockHashHex(){return rootBlockHashHex;}public void setRootBlockHashHex(String v){rootBlockHashHex=v;}public boolean isDeleted(){return deleted;}public void setDeleted(boolean v){deleted=v;}public long getDeletedAtMs(){return deletedAtMs;}public void setDeletedAtMs(long v){deletedAtMs=v;}public Integer getDeletedBlockNumber(){return deletedBlockNumber;}public void setDeletedBlockNumber(Integer v){deletedBlockNumber=v;}}} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/Net_GetDirectMessages_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/Net_GetDirectMessages_Handler.java index 0649ba4d..970dce26 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/Net_GetDirectMessages_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/Net_GetDirectMessages_Handler.java @@ -6,6 +6,7 @@ import server.logic.ws_protocol.JSON.ConnectionContext; import server.logic.ws_protocol.JSON.entyties.Net_Request; import server.logic.ws_protocol.JSON.entyties.Net_Response; import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler; +import server.logic.ws_protocol.JSON.handlers.profile.AvatarValueParser; import server.logic.ws_protocol.JSON.messages.entyties.Net_GetDirectMessages_Request; import server.logic.ws_protocol.JSON.messages.entyties.Net_GetDirectMessages_Response; import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory; @@ -49,6 +50,11 @@ public class Net_GetDirectMessages_Handler implements JsonMessageHandler { String peerLogin = req.getPeerLogin().trim(); long beforeTimeMs = req.getBeforeTimeMs() == null ? 0L : req.getBeforeTimeMs(); String beforeMessageKey = req.getBeforeMessageKey() == null ? "" : req.getBeforeMessageKey().trim(); + long reencryptedBeforeMs = req.getReencryptedBeforeMs() == null ? 0L : req.getReencryptedBeforeMs(); + if (reencryptedBeforeMs < 0) { + return NetExceptionResponseFactory.error(req, WireCodes.Status.BAD_REQUEST, + "BAD_REENCRYPTED_BEFORE", "reencryptedBeforeMs должен быть >= 0"); + } try { List page = SignedMessagesDAO.getInstance().listConversationPage( @@ -56,6 +62,7 @@ public class Net_GetDirectMessages_Handler implements JsonMessageHandler { peerLogin, beforeTimeMs, beforeMessageKey, + reencryptedBeforeMs, limit + 1 ); @@ -129,19 +136,12 @@ public class Net_GetDirectMessages_Handler implements JsonMessageHandler { } private static Net_GetDirectMessages_Response.Avatar parseAvatar(String value) { Net_GetDirectMessages_Response.Avatar out = new Net_GetDirectMessages_Response.Avatar(); - String raw = value == null ? "" : value.trim(); - - // Do not call Matcher.find() twice on the same matcher: the first successful - // call advances it and the second one can make a perfectly valid avatar vanish. - java.util.regex.Matcher ar = java.util.regex.Pattern.compile("AR:([A-Za-z0-9_-]{43})").matcher(raw); - if (ar.find()) { - out.setAr(ar.group(1)); - } - java.util.regex.Matcher sha = java.util.regex.Pattern.compile("SHA256:([A-Fa-f0-9]{64})").matcher(raw); - if (sha.find()) { - out.setSha256Hex(sha.group(1).toLowerCase()); - } + AvatarValueParser.Parsed parsed = AvatarValueParser.parse(value); + if (!parsed.ok()) return out; + out.setAr(parsed.ar()); + out.setSha256Hex(parsed.sha256Hex()); return out; } + } diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/Net_ReceiveIncomingMessage_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/Net_ReceiveIncomingMessage_Handler.java index 39f504e7..0d65eaab 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/Net_ReceiveIncomingMessage_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/Net_ReceiveIncomingMessage_Handler.java @@ -35,6 +35,15 @@ public class Net_ReceiveIncomingMessage_Handler implements JsonMessageHandler { return NetExceptionResponseFactory.error(req, WireCodes.Status.BAD_REQUEST, "BAD_MESSAGE_TYPE", "API принимает только входящие типы 1/3"); } + // Перешифрованная локальная копия type=1 подписана уже получателем, а не исходным + // отправителем. Она никогда не должна приходить через federation API; для неё есть + // ReencryptDirectMessage, который дополнительно проверяет активную key rotation. + if (incoming.messageType == SignedMessageBlock.TYPE_INCOMING_TEXT && incoming.reencryptedAtMs > 0) { + return NetExceptionResponseFactory.error(req, WireCodes.Status.BAD_REQUEST, + "REENCRYPTED_DM_LOCAL_ONLY", + "Перешифрованный входящий DM принимается только через ReencryptDirectMessage"); + } + try { SignedMessagesCore.verifyUsersAndSignature(incoming); } catch (IllegalArgumentException ex) { diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/Net_ReencryptDirectMessage_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/Net_ReencryptDirectMessage_Handler.java new file mode 100644 index 00000000..fdd0b679 --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/Net_ReencryptDirectMessage_Handler.java @@ -0,0 +1,70 @@ +package server.logic.ws_protocol.JSON.messages; + +import server.logic.ws_protocol.JSON.ConnectionContext; +import server.logic.ws_protocol.JSON.entyties.Net_Request; +import server.logic.ws_protocol.JSON.entyties.Net_Response; +import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler; +import server.logic.ws_protocol.JSON.messages.entyties.Net_ReencryptDirectMessage_Request; +import server.logic.ws_protocol.JSON.messages.entyties.Net_ReencryptDirectMessage_Response; +import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory; +import server.logic.ws_protocol.WireCodes; +import shine.db.dao.KeyRotationSessionsDAO; +import shine.db.dao.SignedMessagesDAO; +import shine.db.entities.KeyRotationSessionEntry; +import shine.db.entities.KeyRotationStatus; +import shine.db.entities.SignedMessageEntry; + +/** Сохраняет только локальную перешифрованную type=1/2 копию, без federation/delivery. */ +public final class Net_ReencryptDirectMessage_Handler implements JsonMessageHandler { + @Override + public Net_Response handle(Net_Request baseReq, ConnectionContext ctx) throws Exception { + Net_ReencryptDirectMessage_Request req = (Net_ReencryptDirectMessage_Request) baseReq; + if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) { + return NetExceptionResponseFactory.error(req, WireCodes.Status.UNVERIFIED, "NOT_AUTHENTICATED", "Требуется авторизация"); + } + if (req.getBlobB64() == null || req.getBlobB64().isBlank()) { + return NetExceptionResponseFactory.error(req, WireCodes.Status.BAD_REQUEST, "BAD_FIELDS", "blobB64 обязателен"); + } + String login = ctx.getLogin().trim(); + KeyRotationSessionEntry rotation = KeyRotationSessionsDAO.getInstance().getActiveByLogin(login); + if (rotation == null || rotation.getStatus() != KeyRotationStatus.MESSAGE_MIGRATION) { + return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_MESSAGE_MIGRATION_REQUIRED", + "Перешифровка DM разрешена только на этапе MESSAGE_MIGRATION"); + } + + final SignedMessageBlock block; + try { + block = SignedMessagesCore.parseFromB64(req.getBlobB64()); + if (!block.isContentType()) throw new IllegalArgumentException("BAD_MESSAGE_TYPE"); + if (block.reencryptedAtMs != rotation.getUpdatedAtMs()) throw new IllegalArgumentException("BAD_REENCRYPTED_TIME"); + boolean owned = block.messageType == SignedMessageBlock.TYPE_INCOMING_TEXT + ? login.equalsIgnoreCase(block.toLogin) + : login.equalsIgnoreCase(block.fromLogin); + if (!owned) throw new IllegalArgumentException("MESSAGE_OF_ANOTHER_USER"); + SignedMessagesCore.verifyUsersAndSignature(block); + } catch (IllegalArgumentException e) { + return NetExceptionResponseFactory.error(req, WireCodes.Status.BAD_REQUEST, e.getMessage(), + "Некорректная локальная перешифрованная копия"); + } + + SignedMessageEntry entry = SignedMessagesCore.toEntry(block, "ReencryptDirectMessage", ctx.getSessionId()); + SignedMessagesDAO.ApplyStatus status = SignedMessagesDAO.getInstance().upsertReencryptedLocalCopy(entry); + if (!status.applied()) { + SignedMessageEntry stored = SignedMessagesDAO.getInstance().getByMessageKey(entry.getMessageKey()); + if (stored == null) { + return NetExceptionResponseFactory.error(req, 404, "MESSAGE_NOT_FOUND", "Исходная локальная копия не найдена"); + } + if (stored.getReencryptedAtMs() < entry.getReencryptedAtMs()) { + return NetExceptionResponseFactory.error(req, 409, "STALE_MESSAGE_REVISION", "Локальная копия не была обновлена"); + } + } + + Net_ReencryptDirectMessage_Response resp = new Net_ReencryptDirectMessage_Response(); + resp.setOp(req.getOp()); + resp.setRequestId(req.getRequestId()); + resp.setStatus(WireCodes.Status.OK); + resp.setMessageKey(entry.getMessageKey()); + resp.setReencryptedAtMs(entry.getReencryptedAtMs()); + return resp; + } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/Net_SendMessagePair_Handler.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/Net_SendMessagePair_Handler.java index d7797ca0..74ac945d 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/Net_SendMessagePair_Handler.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/Net_SendMessagePair_Handler.java @@ -33,6 +33,9 @@ public class Net_SendMessagePair_Handler implements JsonMessageHandler { incoming = SignedMessagesCore.parseFromB64(req.getIncomingBlobB64()); outgoing = SignedMessagesCore.parseFromB64(req.getOutgoingBlobB64()); SignedMessagesCore.validatePair(incoming, outgoing); + if (incoming.reencryptedAtMs != 0 || outgoing.reencryptedAtMs != 0) { + throw new IllegalArgumentException("BAD_REENCRYPTED_TIME"); + } } catch (IllegalArgumentException ex) { return NetExceptionResponseFactory.error(req, WireCodes.Status.BAD_REQUEST, ex.getMessage(), "Некорректный формат пары сообщений"); } diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/SignedMessageBlock.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/SignedMessageBlock.java index 9b975fa7..7cf2e956 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/SignedMessageBlock.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/SignedMessageBlock.java @@ -179,7 +179,8 @@ final class SignedMessageBlock { } boolean isSignedByRecipient() { - return messageType == TYPE_MESSAGE_DELETED_BY_RECIPIENT + return (messageType == TYPE_INCOMING_TEXT && reencryptedAtMs > 0) + || messageType == TYPE_MESSAGE_DELETED_BY_RECIPIENT || messageType == TYPE_CONVERSATION_DELETED_BY_RECIPIENT; } diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/entyties/Net_GetDirectMessages_Request.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/entyties/Net_GetDirectMessages_Request.java index 47f1da4c..09e7bee4 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/entyties/Net_GetDirectMessages_Request.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/entyties/Net_GetDirectMessages_Request.java @@ -7,6 +7,7 @@ public class Net_GetDirectMessages_Request extends Net_Request { private Integer limit; private Long beforeTimeMs; private String beforeMessageKey; + private Long reencryptedBeforeMs; public String getPeerLogin() { return peerLogin; } public void setPeerLogin(String peerLogin) { this.peerLogin = peerLogin; } @@ -16,4 +17,6 @@ public class Net_GetDirectMessages_Request extends Net_Request { public void setBeforeTimeMs(Long beforeTimeMs) { this.beforeTimeMs = beforeTimeMs; } public String getBeforeMessageKey() { return beforeMessageKey; } public void setBeforeMessageKey(String beforeMessageKey) { this.beforeMessageKey = beforeMessageKey; } + public Long getReencryptedBeforeMs() { return reencryptedBeforeMs; } + public void setReencryptedBeforeMs(Long reencryptedBeforeMs) { this.reencryptedBeforeMs = reencryptedBeforeMs; } } diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/entyties/Net_ReencryptDirectMessage_Request.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/entyties/Net_ReencryptDirectMessage_Request.java new file mode 100644 index 00000000..fbc60455 --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/entyties/Net_ReencryptDirectMessage_Request.java @@ -0,0 +1,9 @@ +package server.logic.ws_protocol.JSON.messages.entyties; + +import server.logic.ws_protocol.JSON.entyties.Net_Request; + +public final class Net_ReencryptDirectMessage_Request extends Net_Request { + private String blobB64; + public String getBlobB64() { return blobB64; } + public void setBlobB64(String blobB64) { this.blobB64 = blobB64; } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/entyties/Net_ReencryptDirectMessage_Response.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/entyties/Net_ReencryptDirectMessage_Response.java new file mode 100644 index 00000000..f9338a38 --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/entyties/Net_ReencryptDirectMessage_Response.java @@ -0,0 +1,12 @@ +package server.logic.ws_protocol.JSON.messages.entyties; + +import server.logic.ws_protocol.JSON.entyties.Net_Response; + +public final class Net_ReencryptDirectMessage_Response extends Net_Response { + private String messageKey; + private long reencryptedAtMs; + public String getMessageKey() { return messageKey; } + public void setMessageKey(String messageKey) { this.messageKey = messageKey; } + public long getReencryptedAtMs() { return reencryptedAtMs; } + public void setReencryptedAtMs(long reencryptedAtMs) { this.reencryptedAtMs = reencryptedAtMs; } +} diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/sync/AddBlockSyncService.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/sync/AddBlockSyncService.java index 917fd4c5..31a6d646 100644 --- a/SHiNE-server/shine-server-net-protocol/src/main/java/server/sync/AddBlockSyncService.java +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/sync/AddBlockSyncService.java @@ -18,9 +18,11 @@ import java.util.concurrent.*; import java.util.concurrent.atomic.AtomicLong; /** + * @deprecated Legacy direct server-to-server blockchain sync. Not compatible with segmented forks; Arweave/Turbo is supported. * Фоновая репликация AddBlock через общий постоянный WSS-пул на серверы * из локальной таблицы sync_servers. */ +@Deprecated public final class AddBlockSyncService { private static final Logger log = LoggerFactory.getLogger(AddBlockSyncService.class); diff --git a/SHiNE-server/shine-server-net-protocol/src/main/java/server/sync/ArweavePublishSignal.java b/SHiNE-server/shine-server-net-protocol/src/main/java/server/sync/ArweavePublishSignal.java new file mode 100644 index 00000000..51116ee8 --- /dev/null +++ b/SHiNE-server/shine-server-net-protocol/src/main/java/server/sync/ArweavePublishSignal.java @@ -0,0 +1,74 @@ +package server.sync; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Arrays; + +/** + * Неблокирующий мост между приёмом блока по протоколу и Arweave/Turbo publisher-ом. + * + * Net-protocol не зависит от archive-модуля, поэтому publisher регистрирует здесь лёгкий listener. + * Listener обязан только поставить ссылку на уже сохранённый DataItem в свою очередь и не выполнять + * сетевую публикацию в потоке клиента. + */ +public final class ArweavePublishSignal { + private static final Logger log = LoggerFactory.getLogger(ArweavePublishSignal.class); + + public enum Kind { + USER_BLOCK, + KEY_ROTATION_CANDIDATE + } + + public record PendingRef(Kind kind, byte[] dataItemId) { + public PendingRef { + if (kind == null) throw new IllegalArgumentException("kind is null"); + if (dataItemId == null || dataItemId.length != 32) { + throw new IllegalArgumentException("dataItemId must be 32 bytes"); + } + dataItemId = Arrays.copyOf(dataItemId, dataItemId.length); + } + + @Override + public byte[] dataItemId() { + return Arrays.copyOf(dataItemId, dataItemId.length); + } + } + + @FunctionalInterface + public interface Listener { + void onPending(PendingRef item); + } + + private static volatile Listener listener; + + private ArweavePublishSignal() {} + + public static void setListener(Listener value) { + listener = value; + } + + public static void clearListener() { + listener = null; + } + + public static void userBlockAccepted(byte[] dataItemId) { + publish(new PendingRef(Kind.USER_BLOCK, dataItemId)); + } + + public static void keyRotationCandidateAccepted(byte[] dataItemId) { + publish(new PendingRef(Kind.KEY_ROTATION_CANDIDATE, dataItemId)); + } + + private static void publish(PendingRef item) { + Listener current = listener; + if (current == null) return; + try { + current.onPending(item); + } catch (RuntimeException e) { + // Ошибка постановки в быструю очередь не должна превращать уже принятый блок в ошибку клиента: + // arweave_publish_pending остаётся TRUE, и плановый retry подберёт его позже. + log.warn("Cannot enqueue immediate Arweave/Turbo publish; periodic retry will keep the block pending", e); + } + } +} diff --git a/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/codec/ShineUsersCodec.java b/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/codec/ShineUsersCodec.java index a3ab87f5..3f2e0e63 100644 --- a/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/codec/ShineUsersCodec.java +++ b/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/codec/ShineUsersCodec.java @@ -216,10 +216,188 @@ public final class ShineUsersCodec { int formatMajor = raw[5] & 0xFF; int formatMinor = raw[6] & 0xFF; - if (formatMajor != 1 || formatMinor != 2) { + if (formatMajor != 1) { throw new IllegalArgumentException("Unsupported PDA format " + formatMajor + "." + formatMinor); } - return parseUserPdaAccountV12(pdaAddress, slot, rawDataBase64, lastTxSignature, raw); + if (formatMinor == 2) { + return parseUserPdaAccountV12(pdaAddress, slot, rawDataBase64, lastTxSignature, raw); + } + if (formatMinor == 0) { + // Временная read-only совместимость: legacy PDA 1.0 снова читается + // server-sync только для bootstrap старых server-записей. Новые записи + // и update по-прежнему работают только с текущим форматом 1.2. + return parseUserPdaAccountV10(pdaAddress, slot, rawDataBase64, lastTxSignature, raw); + } + throw new IllegalArgumentException("Unsupported PDA format " + formatMajor + "." + formatMinor); + } + + private static UserPdaSnapshot parseUserPdaAccountV10( + String pdaAddress, + long slot, + String rawDataBase64, + String lastTxSignature, + byte[] raw + ) { + int recordLen = u16le(raw, 7); + if (recordLen < 9 + 64 || recordLen > raw.length) { + throw new IllegalArgumentException("Invalid PDA 1.0 record length"); + } + + byte[] useful = new byte[recordLen]; + System.arraycopy(raw, 0, useful, 0, recordLen); + Reader reader = new Reader(useful); + reader.skip(9); + + long createdAtMs = reader.readU64(); + long updatedAtMs = reader.readU64(); + int recordNumber = (int) reader.readU32(); + String prevHash = toHex(reader.readFixed(32)); + String login = reader.readStringU8(); + int blocksCount = reader.readU8(); + + String recoveryKey = null; + String rootKey = null; + String clientKey = null; + String blockchainName = null; + String blockchainKey = null; + long paidLimitBytes = 0L; + long usedBytes = 0L; + int lastBlockNumber = 0; + String lastBlockHash = ""; + String lastBlockSignature = ""; + String arweaveTxId = ""; + String archiveHeadTxId = ""; + String archiveHeadHash = ""; + boolean isServer = false; + int addressFormatType = 0; + int addressFormatVersion = 0; + String serverAddress = ""; + List syncServers = new ArrayList<>(); + List accessServers = new ArrayList<>(); + int sessionsMode = 1; + List sessions = new ArrayList<>(); + int trustedCount = 0; + + boolean seenRecovery = false; + boolean seenRoot = false; + boolean seenClient = false; + boolean seenBlockchain = false; + + for (int i = 0; i < blocksCount; i++) { + int blockType = reader.readU8(); + int blockVersion = reader.readU8(); + if (blockVersion != BLOCK_VERSION_0) { + throw new IllegalArgumentException("Unsupported PDA 1.0 block version: type=" + blockType + " version=" + blockVersion); + } + + switch (blockType) { + case BLOCK_TYPE_RECOVERY_KEY -> { + if (seenRecovery) throw new IllegalArgumentException("Duplicate RecoveryKeyBlock in PDA 1.0"); + recoveryKey = Base58Util.encode(reader.readFixed(32)); + seenRecovery = true; + } + case BLOCK_TYPE_ROOT_KEY -> { + if (seenRoot) throw new IllegalArgumentException("Duplicate RootKeyBlock in PDA 1.0"); + rootKey = Base58Util.encode(reader.readFixed(32)); + seenRoot = true; + } + case BLOCK_TYPE_CLIENT_KEY -> { + if (seenClient) throw new IllegalArgumentException("Duplicate ClientKeyBlock in PDA 1.0"); + clientKey = Base58Util.encode(reader.readFixed(32)); + seenClient = true; + } + case BLOCK_TYPE_BLOCKCHAIN_REGISTRY -> { + if (seenBlockchain) throw new IllegalArgumentException("Duplicate BlockchainRegistryBlock in PDA 1.0"); + int count = reader.readU8(); + if (count < 1) throw new IllegalArgumentException("Empty BlockchainRegistryBlock in PDA 1.0"); + for (int j = 0; j < count; j++) { + int blockchainType = reader.readU8(); + String currentName = reader.readStringU8(); + String currentKey = Base58Util.encode(reader.readFixed(32)); + long currentPaidLimit = reader.readU64(); + long currentUsedBytes = reader.readU64(); + long currentLastBlockNumber = reader.readU32(); + String currentLastBlockHash = toHex(reader.readFixed(32)); + String currentLastBlockSignature = Base58Util.encode(reader.readFixed(64)); + int arweavePresent = reader.readU8(); + String currentArweaveTxId = arweavePresent == 1 ? reader.readStringU8() : ""; + if (arweavePresent != 0 && arweavePresent != 1) { + throw new IllegalArgumentException("Invalid PDA 1.0 arweave_present"); + } + + // Runtime SHiNE использует основной пользовательский blockchain (type=1). + // Если legacy запись содержит несколько chain records, берём первый MAIN_USER. + if (blockchainName == null && blockchainType == BLOCKCHAIN_TYPE_MAIN_USER) { + blockchainName = currentName; + blockchainKey = currentKey; + paidLimitBytes = currentPaidLimit; + usedBytes = currentUsedBytes; + lastBlockNumber = Math.toIntExact(currentLastBlockNumber); + lastBlockHash = currentLastBlockHash; + lastBlockSignature = currentLastBlockSignature; + arweaveTxId = currentArweaveTxId; + } + } + seenBlockchain = true; + } + case BLOCK_TYPE_SERVER_PROFILE -> { + int serverFlag = reader.readU8(); + if (serverFlag != 0 && serverFlag != 1) { + throw new IllegalArgumentException("Invalid PDA 1.0 is_server"); + } + isServer = serverFlag == 1; + if (isServer) { + addressFormatType = reader.readU8(); + addressFormatVersion = reader.readU8(); + serverAddress = reader.readStringU8(); + int count = reader.readU8(); + for (int j = 0; j < count; j++) syncServers.add(reader.readStringU8()); + } + } + case BLOCK_TYPE_ACCESS_SERVERS -> { + int count = reader.readU8(); + for (int j = 0; j < count; j++) accessServers.add(reader.readStringU8()); + } + case BLOCK_TYPE_SESSIONS -> { + sessionsMode = reader.readU8(); + int count = reader.readU8(); + for (int j = 0; j < count; j++) { + int sessionType = reader.readU8(); + int sessionVersion = reader.readU8(); + String sessionName = reader.readStringU8(); + String sessionPubKey = Base58Util.encode(reader.readFixed(32)); + sessions.add(new UserSessionSnapshot(sessionType, sessionVersion, sessionName, sessionPubKey)); + } + } + case BLOCK_TYPE_TRUSTED_STATE -> trustedCount = reader.readU8(); + case BLOCK_TYPE_ARCHIVE_HEAD -> { + archiveHeadTxId = Base64.getUrlEncoder().withoutPadding().encodeToString(reader.readFixed(32)); + archiveHeadHash = toHex(reader.readFixed(32)); + } + default -> throw new IllegalArgumentException("Unsupported PDA 1.0 block type: " + blockType); + } + } + + String signature = Base58Util.encode(reader.readFixed(64)); + if (reader.remaining() != 0) { + throw new IllegalArgumentException("Unexpected tail inside PDA 1.0 record"); + } + if (!seenRecovery || !seenRoot || !seenClient || !seenBlockchain + || recoveryKey == null || rootKey == null || clientKey == null + || blockchainName == null || blockchainKey == null) { + throw new IllegalArgumentException("PDA 1.0 misses required blocks"); + } + + return new UserPdaSnapshot( + pdaAddress, login, recordNumber, slot, lastTxSignature, + recoveryKey, rootKey, clientKey, blockchainName, blockchainKey, paidLimitBytes, + usedBytes, lastBlockNumber, lastBlockHash, lastBlockSignature, arweaveTxId, + archiveHeadTxId, archiveHeadHash, + isServer, addressFormatType, addressFormatVersion, serverAddress, + List.copyOf(syncServers), List.copyOf(accessServers), sessionsMode, List.copyOf(sessions), trustedCount, + createdAtMs, updatedAtMs, prevHash, signature, rawDataBase64, + List.of(new BlockchainForkSnapshot(0, blockchainKey, createdAtMs, paidLimitBytes)) + ); } private static ParsedInstruction parseV12PdaMutationInstruction( @@ -325,6 +503,7 @@ public final class ShineUsersCodec { if (rootKey == null || clientKey == null || blockchainKey == null) { throw new IllegalArgumentException("PDA 1.2 misses required blocks"); } + if (forkCount > 999) throw new IllegalArgumentException("PDA fork limit exceeded: max 999"); String blockchainName = normalizeLogin(login) + "-" + String.format("%03d", forkCount); return new UserPdaSnapshot( pdaAddress, login, recordNumber, slot, lastTxSignature, diff --git a/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/storage/postgres/PostgresStorageRepository.java b/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/storage/postgres/PostgresStorageRepository.java index 7a1b4d1e..9fe3aa7f 100644 --- a/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/storage/postgres/PostgresStorageRepository.java +++ b/SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/storage/postgres/PostgresStorageRepository.java @@ -1,5 +1,6 @@ package sync.storage.postgres; +import sync.util.Base58Util; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; import org.slf4j.Logger; @@ -272,6 +273,11 @@ public final class PostgresStorageRepository snapshots ); + reconcileConfirmedKeyRotations( + connection, + snapshots + ); + upsertSyncState( connection, newState @@ -305,6 +311,11 @@ public final class PostgresStorageRepository snapshots ); + reconcileConfirmedKeyRotations( + connection, + snapshots + ); + upsertSyncState( connection, newState @@ -536,6 +547,90 @@ public final class PostgresStorageRepository } } + /** + * Solana является источником истины для момента завершения ротации PDA. + * После upsert current-снимка сверяем все три новых public key и новый blockchainName. + * Совпадение переводит локальную машину ROTATING_PDA -> PDA_ROTATED в той же DB-транзакции. + */ + private void reconcileConfirmedKeyRotations( + Connection connection, + List snapshots + ) throws Exception { + if (snapshots == null || snapshots.isEmpty()) return; + + String select = """ + SELECT id, new_root_key, new_blockchain_key, new_client_key, candidate_blockchain_name + FROM key_rotation_sessions + WHERE login = ? AND status IN ('CHAIN_READY', 'ROTATING_PDA') + ORDER BY id DESC + LIMIT 1 + FOR UPDATE + """; + + for (ShineUsersCodec.UserPdaSnapshot snapshot : snapshots) { + if (snapshot == null || snapshot.login() == null || snapshot.login().isBlank()) continue; + + try (PreparedStatement ps = connection.prepareStatement(select)) { + ps.setString(1, snapshot.login()); + try (ResultSet rs = ps.executeQuery()) { + if (!rs.next()) continue; + + long rotationId = rs.getLong("id"); + String expectedRoot = rs.getString("new_root_key"); + String expectedBlockchain = rs.getString("new_blockchain_key"); + String expectedClient = rs.getString("new_client_key"); + String expectedBlockchainName = rs.getString("candidate_blockchain_name"); + + String actualRoot = keyToBase64(snapshot.rootKey()); + String actualBlockchain = keyToBase64(snapshot.blockchainKey()); + String actualClient = keyToBase64(snapshot.clientKey()); + + if (!expectedRoot.equals(actualRoot) + || !expectedBlockchain.equals(actualBlockchain) + || !expectedClient.equals(actualClient) + || !expectedBlockchainName.equals(snapshot.blockchainName())) { + continue; + } + + long now = System.currentTimeMillis(); + try (PreparedStatement update = connection.prepareStatement(""" + UPDATE key_rotation_sessions + SET status = 'PDA_ROTATED', + pda_rotation_signature = COALESCE(pda_rotation_signature, ?), + updated_at_ms = ?, + last_error = NULL, + last_error_at_ms = NULL + WHERE id = ? AND status IN ('CHAIN_READY', 'ROTATING_PDA') + """)) { + update.setString(1, snapshot.lastTxSignature() == null || snapshot.lastTxSignature().isBlank() ? null : snapshot.lastTxSignature()); + update.setLong(2, now); + update.setLong(3, rotationId); + if (update.executeUpdate() != 1) continue; + } + try (PreparedStatement update = connection.prepareStatement(""" + UPDATE solana_user_pda_current + SET rotation_status = 'PDA_ROTATED', rotation_session_id = ? + WHERE login = ? AND rotation_session_id = ? AND rotation_status IN ('CHAIN_READY', 'ROTATING_PDA') + """)) { + update.setLong(1, rotationId); + update.setString(2, snapshot.login()); + update.setLong(3, rotationId); + if (update.executeUpdate() != 1) { + throw new SQLException("Rotation session is not attached to synced login=" + snapshot.login()); + } + } + } + } + } + } + + private static String keyToBase64(String base58) { + if (base58 == null || base58.isBlank()) return ""; + byte[] decoded = Base58Util.decode(base58); + if (decoded.length != 32) return ""; + return java.util.Base64.getEncoder().encodeToString(decoded); + } + private void bindSnapshot( PreparedStatement statement, ShineUsersCodec.UserPdaSnapshot snapshot, diff --git a/SHiNE-server/shine-server-solana-users-sync/src/test/java/sync/codec/ShineUsersCodecLegacyV10Test.java b/SHiNE-server/shine-server-solana-users-sync/src/test/java/sync/codec/ShineUsersCodecLegacyV10Test.java new file mode 100644 index 00000000..852c790b --- /dev/null +++ b/SHiNE-server/shine-server-solana-users-sync/src/test/java/sync/codec/ShineUsersCodecLegacyV10Test.java @@ -0,0 +1,119 @@ +package sync.codec; + +import org.junit.jupiter.api.Test; + +import java.io.ByteArrayOutputStream; +import java.nio.charset.StandardCharsets; +import java.util.Base64; + +import static org.junit.jupiter.api.Assertions.*; + +class ShineUsersCodecLegacyV10Test { + + @Test + void readsLegacyV10ServerPdaForBootstrap() { + byte[] raw = buildLegacyServerPda(); + ShineUsersCodec.UserPdaSnapshot snapshot = ShineUsersCodec.parseUserPdaAccount( + "legacy-pda", 123L, Base64.getEncoder().encodeToString(raw), "legacy-tx" + ); + + assertEquals("legacy_server", snapshot.login()); + assertEquals("legacy_server-001", snapshot.blockchainName()); + assertEquals(100_000L, snapshot.paidLimitBytes()); + assertEquals(12_345L, snapshot.usedBytes()); + assertEquals(7, snapshot.lastBlockNumber()); + assertTrue(snapshot.isServer()); + assertEquals(1, snapshot.addressFormatType()); + assertEquals(0, snapshot.addressFormatVersion()); + assertEquals("wss://legacy.example/ws", snapshot.serverAddress()); + assertEquals(java.util.List.of("sync-old"), snapshot.syncServers()); + assertEquals(java.util.List.of("access-old"), snapshot.accessServers()); + assertEquals(1, snapshot.blockchainForks().size()); + assertEquals(snapshot.blockchainKey(), snapshot.blockchainForks().get(0).blockchainKey()); + } + + private static byte[] buildLegacyServerPda() { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + bytes(out, "SHiNE".getBytes(StandardCharsets.UTF_8)); + u8(out, 1); + u8(out, 0); + u16(out, 0); // record_len patch later + u64(out, 1_700_000_000_000L); + u64(out, 1_700_000_001_000L); + u32(out, 3); + bytes(out, repeat(0x11, 32)); + str(out, "legacy_server"); + u8(out, 7); // recovery, root, client, blockchain, server, access, trusted + + u8(out, 0); u8(out, 0); bytes(out, repeat(0x21, 32)); + u8(out, 1); u8(out, 0); bytes(out, repeat(0x22, 32)); + u8(out, 2); u8(out, 0); bytes(out, repeat(0x23, 32)); + + u8(out, 3); u8(out, 0); + u8(out, 1); + u8(out, 1); + str(out, "legacy_server-001"); + bytes(out, repeat(0x24, 32)); + u64(out, 100_000L); + u64(out, 12_345L); + u32(out, 7); + bytes(out, repeat(0x25, 32)); + bytes(out, repeat(0x26, 64)); + u8(out, 1); + str(out, "legacy-arweave-tx"); + + u8(out, 30); u8(out, 0); + u8(out, 1); + u8(out, 1); + u8(out, 0); + str(out, "wss://legacy.example/ws"); + u8(out, 1); + str(out, "sync-old"); + + u8(out, 40); u8(out, 0); + u8(out, 1); + str(out, "access-old"); + + u8(out, 70); u8(out, 0); u8(out, 2); + + bytes(out, repeat(0x27, 64)); + + byte[] record = out.toByteArray(); + record[7] = (byte) (record.length & 0xff); + record[8] = (byte) ((record.length >>> 8) & 0xff); + return record; + } + + private static byte[] repeat(int value, int count) { + byte[] bytes = new byte[count]; + java.util.Arrays.fill(bytes, (byte) value); + return bytes; + } + + private static void str(ByteArrayOutputStream out, String value) { + byte[] bytes = value.getBytes(StandardCharsets.UTF_8); + u8(out, bytes.length); + bytes(out, bytes); + } + + private static void bytes(ByteArrayOutputStream out, byte[] value) { + out.writeBytes(value); + } + + private static void u8(ByteArrayOutputStream out, long value) { + out.write((int) value & 0xff); + } + + private static void u16(ByteArrayOutputStream out, long value) { + u8(out, value); + u8(out, value >>> 8); + } + + private static void u32(ByteArrayOutputStream out, long value) { + for (int i = 0; i < 4; i++) u8(out, value >>> (8 * i)); + } + + private static void u64(ByteArrayOutputStream out, long value) { + for (int i = 0; i < 8; i++) u8(out, value >>> (8 * i)); + } +} diff --git a/SHiNE-server/src/main/java/server/files/PublicFileApiConfigurator.java b/SHiNE-server/src/main/java/server/files/PublicFileApiConfigurator.java new file mode 100644 index 00000000..5703ac1d --- /dev/null +++ b/SHiNE-server/src/main/java/server/files/PublicFileApiConfigurator.java @@ -0,0 +1,14 @@ +package server.files; + +import org.eclipse.jetty.servlet.ServletContextHandler; +import org.eclipse.jetty.servlet.ServletHolder; + +/** Регистрирует HTTP API публичного content-addressed хранилища. */ +public final class PublicFileApiConfigurator { + + private PublicFileApiConfigurator() {} + + public static void register(ServletContextHandler context) { + context.addServlet(new ServletHolder(new PublicFileServlet()), "/files/*"); + } +} diff --git a/SHiNE-server/src/main/java/server/files/PublicFileServlet.java b/SHiNE-server/src/main/java/server/files/PublicFileServlet.java new file mode 100644 index 00000000..6c91db2c --- /dev/null +++ b/SHiNE-server/src/main/java/server/files/PublicFileServlet.java @@ -0,0 +1,407 @@ +package server.files; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.node.ObjectNode; +import jakarta.servlet.http.HttpServlet; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.servlet.http.HttpServletResponse; +import server.logic.ws_protocol.Base64Ws; +import server.logic.ws_protocol.JSON.utils.AuthKeyUtils; +import shine.db.dao.ActiveSessionsDAO; +import shine.db.entities.ActiveSessionEntry; +import utils.config.AppConfig; +import utils.crypto.Ed25519Util; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.nio.charset.StandardCharsets; +import java.nio.file.AtomicMoveNotSupportedException; +import java.nio.file.FileAlreadyExistsException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.StandardCopyOption; +import java.nio.file.attribute.PosixFilePermission; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.sql.SQLException; +import java.util.HexFormat; +import java.util.Objects; +import java.util.Set; +import java.util.regex.Pattern; + +/** + * Публичное content-addressed хранилище SHiNE. + * + * Идентификатор объекта — lowercase hex SHA-256 исходных байтов. Сервер не хранит + * имя, расширение, MIME или владельца внутри пути файла. Одинаковые байты всех + * пользователей дедуплицируются в один объект: data/public-files/. + * + * В production GET/HEAD /files/ рекомендуется отдавать Caddy напрямую с + * того же каталога и кэшировать Cloudflare. Этот servlet оставляет GET/HEAD как + * рабочий fallback; PUT всегда проходит через Java, с проверкой session-signature + * и повторным вычислением SHA-256 полученных байтов. + */ +public final class PublicFileServlet extends HttpServlet { + + private static final ObjectMapper MAPPER = new ObjectMapper(); + private static final Pattern FILE_ID_PATTERN = Pattern.compile("^[0-9a-f]{64}$"); + + private static final String HEADER_SESSION_ID = "X-Shine-Session-Id"; + private static final String HEADER_TIME_MS = "X-Shine-Time-Ms"; + private static final String HEADER_CONTENT_LENGTH = "X-Shine-Content-Length"; + private static final String HEADER_SIGNATURE = "X-Shine-Signature"; + + private static final long DEFAULT_MAX_BYTES = 512L * 1024L * 1024L; + private static final long MAX_AUTH_SKEW_MS = 60_000L; + + private final boolean enabled; + private final Path storageDir; + private final long maxBytes; + + public PublicFileServlet() { + AppConfig config = AppConfig.getInstance(); + this.enabled = readBoolean(config, "public.files.enabled", true); + this.storageDir = Path.of(readString(config, "public.files.storageDir", "data/public-files")) + .toAbsolutePath() + .normalize(); + this.maxBytes = Math.max(1L, readLong(config, "public.files.maxBytes", DEFAULT_MAX_BYTES)); + } + + @Override + protected void doOptions(HttpServletRequest req, HttpServletResponse resp) { + applyCors(resp); + resp.setStatus(HttpServletResponse.SC_NO_CONTENT); + } + + @Override + protected void doPut(HttpServletRequest req, HttpServletResponse resp) throws IOException { + applyCors(resp); + if (!enabled) { + writeError(resp, HttpServletResponse.SC_NOT_FOUND, "FILES_DISABLED", "Публичные файлы отключены на сервере"); + return; + } + + String fileId = extractFileId(req); + if (fileId == null) { + writeError(resp, HttpServletResponse.SC_BAD_REQUEST, "BAD_FILE_ID", "Ожидается lowercase SHA-256 в URL /files/"); + return; + } + + UploadAuth auth; + try { + auth = readAndVerifyUploadAuth(req, fileId); + } catch (AuthFailure failure) { + writeError(resp, failure.httpStatus, failure.code, failure.getMessage()); + return; + } + + if (auth.declaredLength > maxBytes) { + writeError(resp, HttpServletResponse.SC_REQUEST_ENTITY_TOO_LARGE, "FILE_TOO_LARGE", "Файл превышает лимит сервера"); + return; + } + + Files.createDirectories(storageDir); + Path target = safeTarget(fileId); + if (target == null) { + writeError(resp, HttpServletResponse.SC_BAD_REQUEST, "BAD_FILE_ID", "Некорректный SHA-256 файла"); + return; + } + + if (Files.isRegularFile(target)) { + StoredObjectCheck stored = verifyStoredObject(target, fileId); + if (stored.valid()) { + if (stored.size() != auth.declaredLength) { + writeError(resp, HttpServletResponse.SC_CONFLICT, "FILE_ID_CONFLICT", "Файл с таким SHA-256 уже существует с другим размером"); + return; + } + ensurePublicReadable(target); + writeUploadOk(resp, fileId, auth.declaredLength, true); + return; + } + Files.deleteIfExists(target); + } + + Path temp = Files.createTempFile(storageDir, ".public-upload-", ".tmp"); + boolean tempMoved = false; + try { + MessageDigest digest = sha256Digest(); + long actualLength = 0L; + byte[] buffer = new byte[64 * 1024]; + try (InputStream in = req.getInputStream(); OutputStream out = Files.newOutputStream(temp)) { + int read; + while ((read = in.read(buffer)) >= 0) { + if (read == 0) continue; + actualLength += read; + if (actualLength > maxBytes || actualLength > auth.declaredLength) { + writeError(resp, HttpServletResponse.SC_REQUEST_ENTITY_TOO_LARGE, "FILE_TOO_LARGE", "Получено больше байтов, чем разрешено"); + return; + } + digest.update(buffer, 0, read); + out.write(buffer, 0, read); + } + } + + if (actualLength != auth.declaredLength) { + writeError(resp, HttpServletResponse.SC_BAD_REQUEST, "LENGTH_MISMATCH", "Размер загруженного файла не совпал с подписанным размером"); + return; + } + + String actualId = HexFormat.of().formatHex(digest.digest()); + if (!Objects.equals(fileId, actualId)) { + writeError(resp, HttpServletResponse.SC_BAD_REQUEST, "HASH_MISMATCH", "SHA-256 полученных байтов не совпал с адресом файла"); + return; + } + + boolean alreadyExists = false; + try { + try { + Files.move(temp, target, StandardCopyOption.ATOMIC_MOVE); + } catch (AtomicMoveNotSupportedException ignored) { + Files.move(temp, target); + } + tempMoved = true; + } catch (FileAlreadyExistsException race) { + StoredObjectCheck stored = verifyStoredObject(target, fileId); + if (stored.valid() && stored.size() == actualLength) { + alreadyExists = true; + } else { + Files.deleteIfExists(target); + try { + Files.move(temp, target, StandardCopyOption.ATOMIC_MOVE); + } catch (AtomicMoveNotSupportedException ignored) { + Files.move(temp, target); + } + tempMoved = true; + } + } + + ensurePublicReadable(target); + writeUploadOk(resp, fileId, actualLength, alreadyExists); + } finally { + if (!tempMoved) Files.deleteIfExists(temp); + } + } + + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException { + serveFile(req, resp, false); + } + + @Override + protected void doHead(HttpServletRequest req, HttpServletResponse resp) throws IOException { + serveFile(req, resp, true); + } + + private void serveFile(HttpServletRequest req, HttpServletResponse resp, boolean headOnly) throws IOException { + applyCors(resp); + if (!enabled) { + writeError(resp, HttpServletResponse.SC_NOT_FOUND, "FILES_DISABLED", "Публичные файлы отключены на сервере"); + return; + } + + String fileId = extractFileId(req); + Path target = fileId == null ? null : safeTarget(fileId); + if (target == null || !Files.isRegularFile(target)) { + writeError(resp, HttpServletResponse.SC_NOT_FOUND, "FILE_NOT_FOUND", "Файл не найден"); + return; + } + + StoredObjectCheck stored = verifyStoredObject(target, fileId); + if (!stored.valid()) { + Files.deleteIfExists(target); + writeError(resp, HttpServletResponse.SC_NOT_FOUND, "FILE_NOT_FOUND", "Файл не найден"); + return; + } + + resp.setStatus(HttpServletResponse.SC_OK); + resp.setContentType("application/octet-stream"); + resp.setHeader("Content-Length", Long.toString(stored.size())); + resp.setHeader("ETag", "\"" + fileId + "\""); + resp.setHeader("Cache-Control", "public, max-age=31536000, immutable"); + resp.setHeader("Cross-Origin-Resource-Policy", "cross-origin"); + if (!headOnly) { + try (InputStream in = Files.newInputStream(target); OutputStream out = resp.getOutputStream()) { + in.transferTo(out); + } + } + } + + private static StoredObjectCheck verifyStoredObject(Path target, String expectedFileId) throws IOException { + MessageDigest digest = sha256Digest(); + long size = 0L; + byte[] buffer = new byte[64 * 1024]; + try (InputStream in = Files.newInputStream(target)) { + int read; + while ((read = in.read(buffer)) >= 0) { + if (read == 0) continue; + size += read; + digest.update(buffer, 0, read); + } + } + String actual = HexFormat.of().formatHex(digest.digest()); + return new StoredObjectCheck(Objects.equals(expectedFileId, actual), size); + } + + private UploadAuth readAndVerifyUploadAuth(HttpServletRequest req, String fileId) throws AuthFailure { + String sessionId = requiredHeader(req, HEADER_SESSION_ID); + String timeRaw = requiredHeader(req, HEADER_TIME_MS); + String lengthRaw = requiredHeader(req, HEADER_CONTENT_LENGTH); + String signatureRaw = requiredHeader(req, HEADER_SIGNATURE); + + long timeMs; + long declaredLength; + try { + timeMs = Long.parseLong(timeRaw); + declaredLength = Long.parseLong(lengthRaw); + } catch (NumberFormatException badNumber) { + throw new AuthFailure(HttpServletResponse.SC_BAD_REQUEST, "BAD_UPLOAD_HEADERS", "Некорректные числовые заголовки загрузки"); + } + if (declaredLength <= 0L) { + throw new AuthFailure(HttpServletResponse.SC_BAD_REQUEST, "BAD_UPLOAD_LENGTH", "Файл должен содержать хотя бы один байт"); + } + long nowMs = System.currentTimeMillis(); + if (timeMs < nowMs - MAX_AUTH_SKEW_MS || timeMs > nowMs + MAX_AUTH_SKEW_MS) { + throw new AuthFailure(HttpServletResponse.SC_UNAUTHORIZED, "UPLOAD_AUTH_EXPIRED", "Подпись загрузки устарела"); + } + + ActiveSessionEntry session; + try { + session = ActiveSessionsDAO.getInstance().getBySessionId(sessionId); + } catch (SQLException dbError) { + throw new AuthFailure(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "SESSION_LOOKUP_FAILED", "Не удалось проверить пользовательскую сессию"); + } + if (session == null || session.getSessionKey() == null || session.getSessionKey().isBlank()) { + throw new AuthFailure(HttpServletResponse.SC_UNAUTHORIZED, "SESSION_NOT_FOUND", "Активная сессия не найдена"); + } + + byte[] signature; + byte[] publicKey; + try { + signature = Base64Ws.decodeLen(signatureRaw, Ed25519Util.SIGNATURE_LEN, "signature"); + publicKey = AuthKeyUtils.parseEd25519PublicKey(session.getSessionKey(), "sessionKey"); + } catch (RuntimeException badKey) { + throw new AuthFailure(HttpServletResponse.SC_UNAUTHORIZED, "BAD_UPLOAD_SIGNATURE", "Некорректная подпись загрузки"); + } + + String preimage = uploadPreimage(sessionId, fileId, declaredLength, timeMs); + if (!Ed25519Util.verify(preimage.getBytes(StandardCharsets.UTF_8), signature, publicKey)) { + throw new AuthFailure(HttpServletResponse.SC_UNAUTHORIZED, "BAD_UPLOAD_SIGNATURE", "Подпись загрузки не прошла проверку"); + } + return new UploadAuth(declaredLength); + } + + private static String uploadPreimage(String sessionId, String fileId, long size, long timeMs) { + return "PUBLIC_FILE_UPLOAD_V1:" + sessionId + ':' + fileId + ':' + size + ':' + timeMs; + } + + private String extractFileId(HttpServletRequest req) { + String pathInfo = String.valueOf(req.getPathInfo() == null ? "" : req.getPathInfo()).trim(); + if (!pathInfo.startsWith("/") || pathInfo.indexOf('/', 1) >= 0) return null; + String fileId = pathInfo.substring(1); + return FILE_ID_PATTERN.matcher(fileId).matches() ? fileId : null; + } + + private Path safeTarget(String fileId) { + if (fileId == null || !FILE_ID_PATTERN.matcher(fileId).matches()) return null; + Path target = storageDir.resolve(fileId).normalize(); + return target.getParent() != null && target.getParent().equals(storageDir) ? target : null; + } + + private static String requiredHeader(HttpServletRequest req, String name) throws AuthFailure { + String value = req.getHeader(name); + if (value == null || value.isBlank()) { + throw new AuthFailure(HttpServletResponse.SC_UNAUTHORIZED, "MISSING_UPLOAD_AUTH", "Не хватает заголовка " + name); + } + return value.trim(); + } + + private static void ensurePublicReadable(Path target) throws IOException { + try { + Files.setPosixFilePermissions(target, Set.of( + PosixFilePermission.OWNER_READ, + PosixFilePermission.OWNER_WRITE, + PosixFilePermission.GROUP_READ, + PosixFilePermission.OTHERS_READ + )); + } catch (UnsupportedOperationException ignored) { + // Не-POSIX FS: доступом управляет сама файловая система. + } + } + + private static MessageDigest sha256Digest() throws IOException { + try { + return MessageDigest.getInstance("SHA-256"); + } catch (NoSuchAlgorithmException impossible) { + throw new IOException("SHA-256 недоступен", impossible); + } + } + + private static boolean readBoolean(AppConfig config, String key, boolean fallback) { + String value = config.getParam(key); + return value == null || value.isBlank() ? fallback : Boolean.parseBoolean(value.trim()); + } + + private static long readLong(AppConfig config, String key, long fallback) { + String value = config.getParam(key); + if (value == null || value.isBlank()) return fallback; + try { + return Long.parseLong(value.trim()); + } catch (NumberFormatException ignored) { + return fallback; + } + } + + private static String readString(AppConfig config, String key, String fallback) { + String value = config.getParam(key); + return value == null || value.isBlank() ? fallback : value.trim(); + } + + private static void applyCors(HttpServletResponse resp) { + resp.setHeader("Access-Control-Allow-Origin", "*"); + resp.setHeader("Access-Control-Allow-Methods", "GET, HEAD, PUT, OPTIONS"); + resp.setHeader("Access-Control-Allow-Headers", + "Content-Type, X-Shine-Session-Id, X-Shine-Time-Ms, X-Shine-Content-Length, X-Shine-Signature"); + resp.setHeader("Access-Control-Expose-Headers", "Content-Length, ETag"); + resp.setHeader("Vary", "Origin"); + } + + private static void writeUploadOk(HttpServletResponse resp, String fileId, long size, boolean alreadyExists) throws IOException { + ObjectNode payload = MAPPER.createObjectNode(); + payload.put("ok", true); + payload.put("fileId", fileId); + payload.put("sha256", fileId); + payload.put("size", size); + payload.put("alreadyExists", alreadyExists); + writeJson(resp, HttpServletResponse.SC_OK, payload); + } + + private static void writeError(HttpServletResponse resp, int status, String code, String message) throws IOException { + ObjectNode payload = MAPPER.createObjectNode(); + payload.put("ok", false); + payload.put("error", code); + payload.put("message", message); + writeJson(resp, status, payload); + } + + private static void writeJson(HttpServletResponse resp, int status, ObjectNode payload) throws IOException { + resp.setStatus(status); + resp.setCharacterEncoding(StandardCharsets.UTF_8.name()); + resp.setContentType("application/json;charset=UTF-8"); + MAPPER.writeValue(resp.getOutputStream(), payload); + } + + private record StoredObjectCheck(boolean valid, long size) {} + private record UploadAuth(long declaredLength) {} + + private static final class AuthFailure extends Exception { + private final int httpStatus; + private final String code; + + private AuthFailure(int httpStatus, String code, String message) { + super(message); + this.httpStatus = httpStatus; + this.code = code; + } + } +} diff --git a/SHiNE-server/src/main/java/server/keyrotation/KeyRotationRebuildScheduler.java b/SHiNE-server/src/main/java/server/keyrotation/KeyRotationRebuildScheduler.java new file mode 100644 index 00000000..44649a8d --- /dev/null +++ b/SHiNE-server/src/main/java/server/keyrotation/KeyRotationRebuildScheduler.java @@ -0,0 +1,35 @@ +package server.keyrotation; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.ThreadFactory; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicBoolean; + +/** Небольшой background worker, который продолжает rebuild даже если UI был закрыт. */ +public final class KeyRotationRebuildScheduler { + private static final Logger log = LoggerFactory.getLogger(KeyRotationRebuildScheduler.class); + private static final AtomicBoolean STARTED = new AtomicBoolean(false); + private static final KeyRotationRebuildService SERVICE = new KeyRotationRebuildService(); + private static final ScheduledExecutorService EXECUTOR = Executors.newSingleThreadScheduledExecutor(new ThreadFactory() { + @Override public Thread newThread(Runnable r) { + Thread t = new Thread(r, "key-rotation-rebuild"); + t.setDaemon(true); + return t; + } + }); + + private KeyRotationRebuildScheduler() { } + + public static void startOrLog() { + if (!STARTED.compareAndSet(false, true)) return; + EXECUTOR.scheduleWithFixedDelay(() -> { + try { SERVICE.runReady(4); } + catch (Exception e) { log.warn("Key rotation rebuild cycle failed", e); } + }, 1, 2, TimeUnit.SECONDS); + log.info("Key rotation rebuild scheduler started"); + } +} diff --git a/SHiNE-server/src/main/java/server/keyrotation/KeyRotationRebuildService.java b/SHiNE-server/src/main/java/server/keyrotation/KeyRotationRebuildService.java new file mode 100644 index 00000000..7534f134 --- /dev/null +++ b/SHiNE-server/src/main/java/server/keyrotation/KeyRotationRebuildService.java @@ -0,0 +1,91 @@ +package server.keyrotation; + +import blockchain.BchBlockEntry; +import org.slf4j.Logger;import org.slf4j.LoggerFactory; +import server.logic.ws_protocol.JSON.handlers.blockchain.Net_AddBlock_Handler; +import server.logic.ws_protocol.JSON.handlers.blockchain.Net_AddBlock_Handler_utils.BlockchainLocks; +import server.sync.BlockchainResyncGuard; +import shine.db.DbController; +import shine.db.dao.*; +import shine.db.entities.*; +import java.sql.*;import java.util.*;import java.util.concurrent.locks.ReentrantLock; + +/** Deterministic segmented-fork rebuild: stage canonical raw blocks, clear projections, replay oldest->newest. */ +public final class KeyRotationRebuildService { + private static final Logger log=LoggerFactory.getLogger(KeyRotationRebuildService.class); + private final KeyRotationSessionsDAO rotations=KeyRotationSessionsDAO.getInstance(); + private final KeyRotationCandidateBlocksDAO candidates=KeyRotationCandidateBlocksDAO.getInstance(); + private final BlockchainResyncCleanupDAO cleanup=BlockchainResyncCleanupDAO.getInstance(); + private final BlockchainStateDAO states=BlockchainStateDAO.getInstance(); + private final SolanaUserPdaCurrentDAO users=SolanaUserPdaCurrentDAO.getInstance(); + private final CanonicalChainResolver canonical=CanonicalChainResolver.getInstance(); + private final BlockchainForkSegmentsDAO segments=BlockchainForkSegmentsDAO.getInstance(); + private final Net_AddBlock_Handler addBlock=new Net_AddBlock_Handler(); + + public int runReady(int limit){int processed=0;try{for(var s:rotations.listByStatus(KeyRotationStatus.PDA_ROTATED,limit))if(tryRebuild(s))processed++;for(var s:rotations.listByStatus(KeyRotationStatus.REBUILDING_SERVER,Math.max(1,limit-processed)))if(tryRebuild(s))processed++;}catch(Exception e){log.warn("Key rotation rebuild scan failed",e);}return processed;} + public boolean tryRebuild(KeyRotationSessionEntry session){if(session==null)return false;try{var cur=rotations.getById(session.getId());if(cur==null)return false;if(cur.getStatus()==KeyRotationStatus.PDA_ROTATED)cur=rotations.transition(cur.getId(),KeyRotationStatus.PDA_ROTATED,KeyRotationStatus.REBUILDING_SERVER);if(cur.getStatus()!=KeyRotationStatus.REBUILDING_SERVER)return false;rebuild(cur);rotations.clearError(cur.getId());rotations.transition(cur.getId(),KeyRotationStatus.REBUILDING_SERVER,KeyRotationStatus.WALLET_MIGRATION);log.info("Segmented key rotation rebuild complete: login={} {} -> {}",cur.getLogin(),cur.getSourceBlockchainName(),cur.getCandidateBlockchainName());return true;}catch(Exception e){try{rotations.recordError(session.getId(),"REBUILDING_SERVER: "+safeMessage(e));}catch(Exception ignored){}log.warn("Key rotation rebuild failed: id={} login={}",session.getId(),session.getLogin(),e);return false;}} + + private void rebuild(KeyRotationSessionEntry s)throws Exception{ + verifyCurrentPda(s); List cb;try(Connection c=DbController.getInstance().getConnection()){cb=candidates.listBySession(c,s.getId());} + if(cb.size()!=1||s.getProgressTotal()!=1)throw new IllegalStateException("segmented rotation requires exactly one TECH_FORK"); + if(cb.get(0).isArweavePublishPending())throw new IllegalStateException("TECH_FORK is not published"); + String source=s.getSourceBlockchainName(),target=s.getCandidateBlockchainName(); + ReentrantLock first=BlockchainLocks.lockFor(source.compareTo(target)<=0?source:target),second=BlockchainLocks.lockFor(source.compareTo(target)<=0?target:source);first.lock();second.lock();boolean sg=false,tg=false; + try{sg=BlockchainResyncGuard.tryBegin(source);tg=BlockchainResyncGuard.tryBegin(target);if(!sg||!tg)throw new IllegalStateException("another resync/rebuild is active"); + // Crash-safe invariant: staging is the durable immutable source for this rebuild. + // If it already exists, a previous attempt may have crashed at ANY point after staging. + // Therefore every retry deliberately repeats cleanup + segment registration + replay from #0. + if(!hasStaging(s.getId())) stageCanonical(s,cb.get(0)); + validateStaging(s); + cleanup.cleanupLoginForCanonicalReplay(s.getLogin()); + registerCandidateSegment(s); + replayStaging(s); + cleanup.finalizeCanonicalReplay(s.getLogin()); + verifyReplayResult(s,cb.get(0)); + clearStaging(s.getId()); + }finally{if(tg)BlockchainResyncGuard.end(target);if(sg)BlockchainResyncGuard.end(source);second.unlock();first.unlock();} + } + + private boolean hasStaging(long id)throws SQLException{try(Connection c=DbController.getInstance().getConnection();PreparedStatement ps=c.prepareStatement("SELECT 1 FROM key_rotation_rebuild_staging WHERE rotation_session_id=? LIMIT 1")){ps.setLong(1,id);try(ResultSet rs=ps.executeQuery()){return rs.next();}}} + private void stageCanonical(KeyRotationSessionEntry s,KeyRotationCandidateBlockEntry tech)throws Exception{ + try(Connection c=DbController.getInstance().getConnection()){boolean ac=c.getAutoCommit();c.setAutoCommit(false);try{ + try(PreparedStatement d=c.prepareStatement("DELETE FROM key_rotation_rebuild_staging WHERE rotation_session_id=?")){d.setLong(1,s.getId());d.executeUpdate();} + String ins="INSERT INTO key_rotation_rebuild_staging(rotation_session_id,logical_block_number,physical_fork_number,blockchain_key,block_bytes,block_hash) VALUES(?,?,?,?,?,?)"; + try(PreparedStatement ps=c.prepareStatement(ins)){ + for(int n=0;n<=s.getForkFromBlock();n++){BlockEntry e=canonical.getBlock(c,s.getSourceBlockchainName(),n);if(e==null)throw new IllegalStateException("canonical block missing #"+n);BchBlockEntry b=new BchBlockEntry(e.getBlockBytes());ps.setLong(1,s.getId());ps.setInt(2,n);ps.setInt(3,e.getForkNumber());ps.setString(4,Base64.getEncoder().encodeToString(b.getOwner32()));ps.setBytes(5,e.getBlockBytes());ps.setBytes(6,e.getBlockHash());ps.addBatch();} + BchBlockEntry b=new BchBlockEntry(tech.getBlockBytes());ps.setLong(1,s.getId());ps.setInt(2,b.blockNumber);ps.setInt(3,forkOf(s.getCandidateBlockchainName()));ps.setString(4,s.getNewBlockchainKey());ps.setBytes(5,tech.getBlockBytes());ps.setBytes(6,tech.getBlockHash());ps.addBatch();ps.executeBatch(); + }c.commit();}catch(Exception e){c.rollback();throw e;}finally{c.setAutoCommit(ac);}} + } + private void registerCandidateSegment(KeyRotationSessionEntry s)throws Exception{try(Connection c=DbController.getInstance().getConnection()){segments.upsert(c,new BlockchainForkSegmentsDAO.Segment(s.getLogin(),forkOf(s.getCandidateBlockchainName()),forkOf(s.getSourceBlockchainName()),s.getForkFromBlock(),s.getForkFromHash(),s.getForkFromBlock()+1,System.currentTimeMillis()));}} + private void replayStaging(KeyRotationSessionEntry s)throws Exception{ + SolanaUserPdaCurrentEntry u=users.getByLogin(s.getLogin());long limit=u!=null&&u.getPaidLimitBytes()>0?u.getPaidLimitBytes():100_000L;long cumulative=0;int currentFork=-1;int prevNumber=-1;byte[] prevHash=null; + try(Connection c=DbController.getInstance().getConnection();PreparedStatement ps=c.prepareStatement("SELECT logical_block_number,physical_fork_number,blockchain_key,block_bytes,block_hash FROM key_rotation_rebuild_staging WHERE rotation_session_id=? ORDER BY logical_block_number ASC")){ps.setLong(1,s.getId());try(ResultSet rs=ps.executeQuery()){while(rs.next()){ + int n=rs.getInt(1),f=rs.getInt(2);String key=rs.getString(3);byte[] raw=rs.getBytes(4),hash=rs.getBytes(5);String bch=s.getLogin()+"-"+String.format("%03d",f); + if(f!=currentFork){BlockchainStateEntry st=new BlockchainStateEntry();st.setBlockchainName(bch);st.setLogin(s.getLogin());st.setBlockchainKey(key);st.setSizeLimit(limit);st.setFileSizeBytes(cumulative);st.setLastBlockNumber(prevNumber);st.setLastBlockHash(prevHash);st.setUpdatedAtMs(System.currentTimeMillis());states.insertIfMissing(st);currentFork=f;} + String target=bch;BlockchainResyncGuard.withBypass(target,()->{Net_AddBlock_Handler.ArweaveImportResult r=addBlock.addBlockFromReplay(target,raw);if(!r.ok())throw new IllegalStateException("canonical replay rejected #"+n+": "+r.reasonCode());}); + cumulative+=raw.length;prevNumber=n;prevHash=hash; + }}} + } + + private void validateStaging(KeyRotationSessionEntry s)throws Exception{ + int expected=0,last=-1;byte[] previousHash=null; + try(Connection c=DbController.getInstance().getConnection();PreparedStatement ps=c.prepareStatement("SELECT logical_block_number,block_bytes,block_hash FROM key_rotation_rebuild_staging WHERE rotation_session_id=? ORDER BY logical_block_number ASC")){ + ps.setLong(1,s.getId());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("rebuild staging gap: expected #"+expected+" got #"+n);BchBlockEntry b=new BchBlockEntry(raw);if(b.blockNumber!=n)throw new IllegalStateException("rebuild staging block number mismatch #"+n);if(n==0 && !(b.body instanceof blockchain.body.HeaderBody))throw new IllegalStateException("canonical history must start with HEADER #0");if(n>0 && (previousHash==null||!Arrays.equals(b.prevHash32,previousHash)))throw new IllegalStateException("rebuild staging prevHash mismatch #"+n);if(hash==null||hash.length!=32||!Arrays.equals(hash,b.getHash32()))throw new IllegalStateException("rebuild staging hash mismatch #"+n);previousHash=hash;last=n;expected++;}} + } + int expectedTip=s.getForkFromBlock()+1;if(last!=expectedTip)throw new IllegalStateException("rebuild staging tip mismatch: expected #"+expectedTip+" got #"+last); + } + + private void verifyReplayResult(KeyRotationSessionEntry s,KeyRotationCandidateBlockEntry tech)throws Exception{ + BlockchainStateEntry st=states.getByBlockchainName(s.getCandidateBlockchainName());if(st==null)throw new IllegalStateException("candidate blockchain state missing after replay"); + BchBlockEntry b=new BchBlockEntry(tech.getBlockBytes()); + if(st.getLastBlockNumber()!=b.blockNumber)throw new IllegalStateException("replay tip number mismatch"); + if(st.getLastBlockHash()==null||!Arrays.equals(st.getLastBlockHash(),b.getHash32()))throw new IllegalStateException("replay tip hash mismatch"); + BlockEntry zero=canonical.getBlock(s.getCandidateBlockchainName(),0);if(zero==null){throw new IllegalStateException("canonical HEADER #0 missing after replay");} + BchBlockEntry header=new BchBlockEntry(zero.getBlockBytes());if(!(header.body instanceof blockchain.body.HeaderBody))throw new IllegalStateException("canonical block #0 is not HEADER"); + } + + private void clearStaging(long id)throws SQLException{try(Connection c=DbController.getInstance().getConnection();PreparedStatement ps=c.prepareStatement("DELETE FROM key_rotation_rebuild_staging WHERE rotation_session_id=?")){ps.setLong(1,id);ps.executeUpdate();}} + private void verifyCurrentPda(KeyRotationSessionEntry s)throws Exception{var u=users.getByLogin(s.getLogin());if(u==null)throw new IllegalStateException("current PDA not found");if(!s.getCandidateBlockchainName().equals(u.getBlockchainName()))throw new IllegalStateException("current PDA blockchainName mismatch");if(!s.getNewBlockchainKey().equals(u.getBlockchainKey()))throw new IllegalStateException("current PDA blockchain key mismatch");} + private static int forkOf(String n){int d=n.lastIndexOf('-');return Integer.parseInt(n.substring(d+1));} + private static String safeMessage(Throwable t){String v=t==null?"unknown":String.valueOf(t.getMessage());return v.length()>1000?v.substring(0,1000):v;} +} diff --git a/SHiNE-server/src/main/java/server/sync/PeriodicBlockchainSyncService.java b/SHiNE-server/src/main/java/server/sync/PeriodicBlockchainSyncService.java index 9fdc7d15..90d295a9 100644 --- a/SHiNE-server/src/main/java/server/sync/PeriodicBlockchainSyncService.java +++ b/SHiNE-server/src/main/java/server/sync/PeriodicBlockchainSyncService.java @@ -28,11 +28,13 @@ import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; /** + * @deprecated Legacy direct server-to-server blockchain sync. Not compatible with segmented forks; Arweave/Turbo is supported. * Плановый межсерверный sync блокчейнов. * Сейчас реализует: * - догоняющую синхронизацию отсутствующего хвоста; * - базовый full-resync при divergence, если удалённая цепочка сильнее. */ +@Deprecated public final class PeriodicBlockchainSyncService { private static final Logger log = LoggerFactory.getLogger(PeriodicBlockchainSyncService.class); @@ -228,11 +230,11 @@ public final class PeriodicBlockchainSyncService { try { BlockchainResyncCleanupDAO.CleanupResult cleanup = RESYNC_CLEANUP_DAO.cleanupBlockchainForFullResync(blockchainName); - log.info("Blockchain resync cleanup finished: blockchainName={} login={} likesAdjusted={} repliesAdjusted={} deletedBlocks={} deletedState={}", + log.info("Blockchain resync cleanup finished: blockchainName={} login={} deletedReactionsState={} deletedConnectionsState={} deletedBlocks={} deletedState={}", blockchainName, cleanup.login(), - cleanup.likesAdjustedRows(), - cleanup.repliesAdjustedRows(), + cleanup.deletedReactionsStateRows(), + cleanup.deletedConnectionsStateRows(), cleanup.deletedBlocksRows(), cleanup.deletedBlockchainStateRows()); diff --git a/SHiNE-server/src/main/java/server/ws/WsServer.java b/SHiNE-server/src/main/java/server/ws/WsServer.java index 9a84e00a..40cec097 100644 --- a/SHiNE-server/src/main/java/server/ws/WsServer.java +++ b/SHiNE-server/src/main/java/server/ws/WsServer.java @@ -1,5 +1,7 @@ package server.ws; +import server.keyrotation.KeyRotationRebuildScheduler; + import org.eclipse.jetty.server.Server; import org.eclipse.jetty.servlet.ServletContextHandler; import org.eclipse.jetty.websocket.server.config.JettyWebSocketServletContainerInitializer; @@ -9,6 +11,7 @@ import server.archive.ArweaveBlockPublisherScheduler; import server.archive.ArweaveBlockSyncScheduler; import server.debug.DebugApiConfigurator; import server.files.DmFileApiConfigurator; +import server.files.PublicFileApiConfigurator; import server.sync.PeriodicBlockchainSyncService; import server.sync.PeriodicDmDeliveryService; import server.sync.SolanaUsersSyncStartupService; @@ -51,16 +54,19 @@ public final class WsServer { // ============================================================ // 1.1) Загрузка списка серверов синхронизации из Solana PDA // ============================================================ - SyncServersBootstrapService.refreshFromSolanaOrLog(); + // Legacy direct server-to-server sync is retired. Do not bootstrap sync_servers. + // Arweave/Turbo is the supported blockchain recovery/synchronization source. // ============================================================ // 1.2) Плановый межсерверный sync блокчейнов // ============================================================ - PeriodicBlockchainSyncService.startOrLog(); + // Legacy direct server-to-server blockchain sync is intentionally disabled. + // PeriodicBlockchainSyncService is retained only as deprecated historical code. // ANS-104: publish locally-created signed user blocks and discover blocks published by other servers. ArweaveBlockPublisherScheduler.startOrLog(); ArweaveBlockSyncScheduler.startOrLog(); + KeyRotationRebuildScheduler.startOrLog(); // ============================================================ // 2) Запуск Jetty WS @@ -77,6 +83,10 @@ public final class WsServer { // Зашифрованные вложения личных сообщений: PUT/GET /dm-files/{sha256-base58} DmFileApiConfigurator.register(context); + // Публичные immutable-вложения каналов: PUT/GET/HEAD /files/{sha256-hex}. + // В production GET/HEAD может перехватывать Caddy и отдавать файл прямо с диска. + PublicFileApiConfigurator.register(context); + // Инициализация контейнера WebSocket JettyWebSocketServletContainerInitializer.configure(context, (servletContext, wsContainer) -> { // Таймаут простоя соединения (Jetty 11 синтаксис) diff --git a/SHiNE-server/src/main/resources/application.properties b/SHiNE-server/src/main/resources/application.properties index cf011901..e40dba6d 100644 --- a/SHiNE-server/src/main/resources/application.properties +++ b/SHiNE-server/src/main/resources/application.properties @@ -72,6 +72,15 @@ dm.files.storageDir=data/dm-files # Значение 50 MiB сохранено для совместимости с DM file v1. dm.files.maxBytes=52428816 +# ================================ +# Public immutable file storage +# ================================ +# Исходные байты публичного вложения. Имя файла = lowercase hex SHA-256(bytes). +# GET/HEAD работает через Java даже без Caddy; в production можно отдать этот путь напрямую Caddy. +public.files.enabled=true +public.files.storageDir=data/public-files +public.files.maxBytes=536870912 + webpush.vapid.public=BOdoWZndZRaNe9kyUFsJ5-xEfFABXNKennAKg15Z7ycAwUIQ7yDV_sIWWYJCwJriN4g9oU-CyJPrn1U6lfxuDbI webpush.vapid.private=3hCt7XxTvLzuoxinjT5QcKRQEBnGZHXn8ZilU31RPNE webpush.vapid.subject=mailto:admin@shine.local @@ -137,7 +146,7 @@ test.freeAvatar.walletJwkPath= # ============================================================ # Arweave per-user-block transport (ANS-104) -# Test namespace: each user DataItem is signed with App=test5590. +# Test namespace: each user DataItem is signed with App=test5591. # Channel DataItems additionally contain c=. # ============================================================ arweave.blocks.publish.enabled=false @@ -153,7 +162,11 @@ arweave.blocks.publish.confirmTimeoutMinutes=180 arweave.blocks.sync.enabled=false arweave.blocks.sync.intervalMinutes=15 arweave.blocks.sync.gateway=https://turbo-gateway.com +# Fallback к metadata API Turbo, если общий AR.IO index ещё не знает offsets. +arweave.blocks.sync.turboApiBase=https://turbo.ardrive.io +# Уже найденные GraphQL DataItem с временно неизвестными координатами ретраятся чаще полного discovery. +arweave.blocks.sync.locationRetrySeconds=30 arweave.blocks.sync.pageSize=100 arweave.blocks.sync.queueBatchSize=10000 arweave.blocks.sync.startBlockHeight=0 -arweave.blocks.sync.maxRootBundleBytes=268435456 +arweave.blocks.sync.maxDataItemBytes=8388608 diff --git a/SHiNE-server/src/test/java/test/it/blockchain/AddBlockSender.java b/SHiNE-server/src/test/java/test/it/blockchain/AddBlockSender.java index 9a659908..1d344a6f 100644 --- a/SHiNE-server/src/test/java/test/it/blockchain/AddBlockSender.java +++ b/SHiNE-server/src/test/java/test/it/blockchain/AddBlockSender.java @@ -2,6 +2,7 @@ package test.it.blockchain; import blockchain.Ans104DataItem; import blockchain.BchBlockEntry; +import blockchain.ShineProtocolTags; import blockchain.body.*; import test.it.utils.TestConfig; import test.it.utils.TestIds; @@ -68,6 +69,7 @@ public final class AddBlockSender { int blockNumber = state.nextBlockNumber(); byte[] prevHash32 = state.prevHash32ForNext(); + byte[] back32Hash32 = state.back32Hash32ForNext(); long tsSec = System.currentTimeMillis() / 1000L; short type = typeOf(body); @@ -76,13 +78,15 @@ public final class AddBlockSender { byte[] bodyBytes = body.toBytes(); - byte[] frame = buildFrame(prevHash32, blockNumber, tsSec, type, subType, version, bodyBytes); + byte[] frame = buildFrame(prevHash32, back32Hash32, blockNumber, tsSec, type, subType, version, bodyBytes); byte[] owner32 = utils.crypto.Ed25519Util.derivePublicKey(loginPrivKey); List tags = new ArrayList<>(); - tags.add(new Ans104DataItem.Tag("App", "test5590")); + tags.add(new Ans104DataItem.Tag(ShineProtocolTags.APP_TAG_NAME, ShineProtocolTags.APP_TAG_VALUE)); + String typeTag = typeTagFor(type); + if (typeTag != null) tags.add(new Ans104DataItem.Tag(ShineProtocolTags.TYPE_TAG_NAME, typeTag)); String channelSlug = channelSlugFor(body); - if (channelSlug != null) tags.add(new Ans104DataItem.Tag("c_test5590", channelSlug)); + if (channelSlug != null) tags.add(new Ans104DataItem.Tag(ShineProtocolTags.CHANNEL_TAG_NAME, channelSlug)); byte[] signingMessage = Ans104DataItem.buildSigningMessage(owner32, tags, frame); byte[] signature64 = utils.crypto.Ed25519Util.sign(signingMessage, loginPrivKey); @@ -167,7 +171,9 @@ public final class AddBlockSender { private static short typeOf(BodyRecord body) { if (body instanceof HeaderBody) return HeaderBody.TYPE; if (body instanceof CreateChannelBody) return CreateChannelBody.TYPE; - if (body instanceof TextBody) return TextBody.TYPE; + if (body instanceof ForkBody) return ForkBody.TYPE; + if (body instanceof TextLineBody || body instanceof TextReplyBody || body instanceof TextRatingBody) return TextLineBody.TYPE; + if (body instanceof StatusActionBody) return StatusActionBody.TYPE; if (body instanceof ReactionBody) return ReactionBody.TYPE; if (body instanceof ConnectionBody) return ConnectionBody.TYPE; if (body instanceof UserParamBody) return UserParamBody.TYPE; @@ -177,7 +183,11 @@ public final class AddBlockSender { private static short subTypeOf(BodyRecord body) { if (body instanceof HeaderBody hb) return hb.subType; if (body instanceof CreateChannelBody cb) return cb.subType; - if (body instanceof TextBody tb) return tb.subType; + if (body instanceof ForkBody fb) return fb.subType; + if (body instanceof TextLineBody tb) return tb.subType; + if (body instanceof TextReplyBody tb) return tb.subType; + if (body instanceof TextRatingBody tb) return tb.subType; + if (body instanceof StatusActionBody sb) return sb.subType; if (body instanceof ReactionBody rb) return rb.subType; if (body instanceof ConnectionBody cb) return cb.subType; if (body instanceof UserParamBody ub) return ub.subType; @@ -187,7 +197,11 @@ public final class AddBlockSender { private static short versionOf(BodyRecord body) { if (body instanceof HeaderBody hb) return hb.version; if (body instanceof CreateChannelBody cb) return cb.version; - if (body instanceof TextBody tb) return tb.version; + if (body instanceof ForkBody fb) return fb.version; + if (body instanceof TextLineBody tb) return tb.version; + if (body instanceof TextReplyBody tb) return tb.version; + if (body instanceof TextRatingBody tb) return tb.version; + if (body instanceof StatusActionBody sb) return sb.version; if (body instanceof ReactionBody rb) return rb.version; if (body instanceof ConnectionBody cb) return cb.version; if (body instanceof UserParamBody ub) return ub.version; @@ -196,11 +210,20 @@ public final class AddBlockSender { // ---------- Frame v1 + signed channel tag helpers ---------- + private static String typeTagFor(short type) { + return switch (type & 0xFFFF) { + case 0 -> "tech"; + case 3 -> "conn"; + case 4 -> "prof"; + default -> null; + }; + } + private String channelSlugFor(BodyRecord body) { if (body instanceof CreateChannelBody ccb) { return shine.db.channels.ChannelNameRules.toCanonicalSlug(ccb.channelName); } - if (body instanceof TextBody tb && tb.isLineMessage() && tb.lineCode > 0) { + if (body instanceof TextLineBody tb && tb.lineCode > 0) { String slug = channelSlugByRoot.get(tb.lineCode); if (slug == null) { throw new IllegalStateException("Unknown channel slug for lineCode=" + tb.lineCode); @@ -211,6 +234,7 @@ public final class AddBlockSender { } private static byte[] buildFrame(byte[] prevHash32, + byte[] back32Hash32, int blockNumber, long tsSec, short type, @@ -221,12 +245,16 @@ public final class AddBlockSender { if (prevHash32 == null || prevHash32.length != 32) { throw new IllegalArgumentException("prevHash32 must be 32 bytes"); } + if (back32Hash32 == null || back32Hash32.length != 32) { + throw new IllegalArgumentException("back32Hash32 must be 32 bytes"); + } int bodyLen = bodyBytes == null ? 0 : bodyBytes.length; int blockSize = BchBlockEntry.FRAME_HEADER_SIZE + bodyLen; java.nio.ByteBuffer bb = java.nio.ByteBuffer.allocate(blockSize).order(java.nio.ByteOrder.BIG_ENDIAN); bb.putShort((short) BchBlockEntry.FRAME_CODE_V1); bb.put(prevHash32); + bb.put(back32Hash32); bb.putInt(blockSize); bb.putInt(blockNumber); bb.putLong(tsSec); diff --git a/SHiNE-server/src/test/java/test/it/blockchain/ChainState.java b/SHiNE-server/src/test/java/test/it/blockchain/ChainState.java index ee9f596d..91729654 100644 --- a/SHiNE-server/src/test/java/test/it/blockchain/ChainState.java +++ b/SHiNE-server/src/test/java/test/it/blockchain/ChainState.java @@ -3,7 +3,8 @@ package test.it.blockchain; import blockchain.body.BodyRecord; import blockchain.body.BodyHasLine; import blockchain.body.CreateChannelBody; -import blockchain.body.TextBody; +import blockchain.body.ForkBody; +import blockchain.body.TextLineBody; import java.util.HashMap; import java.util.Map; @@ -16,10 +17,10 @@ import java.util.Map; * - map blockNumber -> hash32 * * Линии: - * - TECH (type=0): только CREATE_CHANNEL (hasLine), root = HEADER + * - TECH (type=0): CREATE_CHANNEL и TECH_FORK, root = HEADER * - TEXT (type=1): линии каналов, root = HEADER (канал "0") или CREATE_CHANNEL (канал "X") * - CONNECTION (type=3): одна линия - * - USER_PARAM (type=4): одна линия + * - USER_PROFILE (type=4): одна линия * * ВАЖНО: * - prevLineNumber — это GLOBAL blockNumber предыдущего блока линии. @@ -122,10 +123,18 @@ public final class ChainState { } public byte[] prevHash32ForNext() { - if (lastBlockNumber < 0) return ZERO32; + if (lastBlockNumber < 0) return ZERO32.clone(); return hexToBytes32(lastBlockHashHex); } + public byte[] back32Hash32ForNext() { + int next = nextBlockNumber(); + if (next < 32) return ZERO32.clone(); + byte[] h = hash32ByNumber.get(next - 32); + if (h == null || h.length != 32) throw new IllegalStateException("Missing hash for block " + (next - 32)); + return h.clone(); + } + public byte[] headerHash32() { return headerHash32 == null ? null : headerHash32.clone(); } @@ -277,16 +286,18 @@ public final class ChainState { int t = type & 0xFFFF; - // ---- TECH (CREATE_CHANNEL) ---- - if (t == TYPE_TECH && body instanceof CreateChannelBody ccb) { + // ---- TECH (CREATE_CHANNEL / TECH_FORK) ---- + if (t == TYPE_TECH && body instanceof BodyHasLine tech) { techLine.lastGlobalNumber = blockNumber; techLine.lastHashHex = hex64; - techLine.lastThisLineNumber = ccb.thisLineNumber; - - // ВАЖНО: CREATE_CHANNEL — это root нового текстового канала: - // lineCode для этого канала = blockNumber CREATE_CHANNEL - registerTextChannelRoot(blockNumber, hash32); + techLine.lastThisLineNumber = tech.lineSeq(); + if (body instanceof CreateChannelBody) { + // CREATE_CHANNEL одновременно является root нового текстового канала. + registerTextChannelRoot(blockNumber, hash32); + } else if (!(body instanceof ForkBody)) { + throw new IllegalStateException("Unknown TECH line body: " + body.getClass()); + } return; } @@ -305,8 +316,8 @@ public final class ChainState { } // ---- TEXT channels (POST/EDIT_POST) ---- - if (t == TYPE_TEXT && body instanceof TextBody tb) { - if (tb.isLineMessage()) { + if (t == TYPE_TEXT && body instanceof TextLineBody tb) { + { int lineCode = tb.lineCode; ChannelLineState channel = textChannels.get(lineCode); diff --git a/SHiNE-server/src/test/java/test/it/cases/IT_03_AddBlock_NoAuth.java b/SHiNE-server/src/test/java/test/it/cases/IT_03_AddBlock_NoAuth.java index 1d85001a..e8ece631 100644 --- a/SHiNE-server/src/test/java/test/it/cases/IT_03_AddBlock_NoAuth.java +++ b/SHiNE-server/src/test/java/test/it/cases/IT_03_AddBlock_NoAuth.java @@ -4,7 +4,8 @@ import blockchain.MsgSubType; import blockchain.body.ConnectionBody; import blockchain.body.CreateChannelBody; import blockchain.body.HeaderBody; -import blockchain.body.TextBody; +import blockchain.body.TextLineBody; +import blockchain.body.TextReplyBody; import shine.db.DbController; import test.it.blockchain.AddBlockSender; import test.it.blockchain.ChainState; @@ -14,6 +15,7 @@ import test.it.utils.log.TestResult; import test.it.utils.ws.WsSession; import java.time.Duration; +import utils.crypto.Ed25519Util; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; @@ -27,7 +29,7 @@ import static org.junit.jupiter.api.Assertions.*; * CONNECTION (type=3): * - всегда имеет hasLine (lineCode+prevLineNumber+prevLineHash32+thisLineNumber) * - всегда имеет target: - * toBlockchainName + toBlockGlobalNumber + toBlockHash32 + * toLogin + toForkNumber + toBlockGlobalNumber + toBlockHash32 * * Правило target для связей/подписок: * - FRIEND/CONTACT -> target = HEADER цели (blockNumber=0) @@ -75,7 +77,7 @@ public class IT_03_AddBlock_NoAuth { ChainState st1 = new ChainState(); AddBlockSender sender1 = new AddBlockSender(ws, st1, u1, bch1, TestConfig.getBlockchainPrivatKey(u1)); - sender1.send(new HeaderBody(u1), t); + sender1.send(new HeaderBody(u1, Ed25519Util.derivePublicKey(TestConfig.getBlockchainPrivatKey(u1))), t); assertTrue(st1.hasHeader()); int u1HeaderBlock = 0; @@ -88,12 +90,12 @@ public class IT_03_AddBlock_NoAuth { // POST в канал "0" { var ln = st1.nextTextLineByRoot(root0); - sender1.send(new TextBody( - MsgSubType.TEXT_POST, + sender1.send(new TextLineBody( root0, ln.prevLineNumber, ln.prevLineHash32, ln.thisLineNumber, - "U1: story/post in channel 0", - null, null, null + MsgSubType.TEXT_POST, + null, null, null, null, + "U1: story/post in channel 0" ), t); } @@ -148,12 +150,12 @@ public class IT_03_AddBlock_NoAuth { byte[] newsPost0Hash; { var ln = st1.nextTextLineByRoot(newsRootBlock); - sender1.send(new TextBody( - MsgSubType.TEXT_POST, + sender1.send(new TextLineBody( newsRootBlock, ln.prevLineNumber, ln.prevLineHash32, ln.thisLineNumber, - "U1: News post #0", - null, null, null + MsgSubType.TEXT_POST, + null, null, null, null, + "U1: News post #0" ), t); newsPost0Block = st1.lastBlockNumber(); @@ -164,26 +166,26 @@ public class IT_03_AddBlock_NoAuth { // POST #1 в канал "News" { var ln = st1.nextTextLineByRoot(newsRootBlock); - sender1.send(new TextBody( - MsgSubType.TEXT_POST, + sender1.send(new TextLineBody( newsRootBlock, ln.prevLineNumber, ln.prevLineHash32, ln.thisLineNumber, - "U1: News post #1", - null, null, null + MsgSubType.TEXT_POST, + null, null, null, null, + "U1: News post #1" ), t); } - // EDIT_POST (в линии канала) -> target на ОРИГИНАЛЬНЫЙ POST (без toBlockchainName) + // EDIT_POST -> compact target на собственный оригинальный POST: number + hash { var ln = st1.nextTextLineByRoot(newsRootBlock); - sender1.send(new TextBody( - MsgSubType.TEXT_EDIT_POST, + sender1.send(new TextLineBody( newsRootBlock, ln.prevLineNumber, ln.prevLineHash32, ln.thisLineNumber, - "U1: News post #0 (EDIT)", - null, + MsgSubType.TEXT_EDIT_POST, + null, null, newsPost0Block, - newsPost0Hash + newsPost0Hash, + "U1: News post #0 (EDIT)" ), t); } @@ -193,7 +195,7 @@ public class IT_03_AddBlock_NoAuth { ChainState st2 = new ChainState(); AddBlockSender sender2 = new AddBlockSender(ws, st2, u2, bch2, TestConfig.getBlockchainPrivatKey(u2)); - sender2.send(new HeaderBody(u2), t); + sender2.send(new HeaderBody(u2, Ed25519Util.derivePublicKey(TestConfig.getBlockchainPrivatKey(u2))), t); assertTrue(st2.hasHeader()); int u2HeaderBlock = 0; @@ -206,17 +208,17 @@ public class IT_03_AddBlock_NoAuth { // 1) U1 подписался на U2 (FOLLOW на пользователя -> target=HEADER U2) sendConnection(sender1, st1, MsgSubType.CONNECTION_FOLLOW, - bch2, u2HeaderBlock, u2HeaderHash, + u2, u2HeaderBlock, u2HeaderHash, "U1 follows U2 (target=U2 HEADER)", t); // 2) U2 подписался на канал U1 "News" (FOLLOW на канал -> target=root CREATE_CHANNEL U1) sendConnection(sender2, st2, MsgSubType.CONNECTION_FOLLOW, - bch1, newsRootBlock, newsRootHash, + u1, newsRootBlock, newsRootHash, "U2 follows U1 channel 'News' (target=U1 CREATE_CHANNEL root)", t); // 3) U2 подписался на второй канал U1 "Updates" sendConnection(sender2, st2, MsgSubType.CONNECTION_FOLLOW, - bch1, updatesRootBlock, updatesRootHash, + u1, updatesRootBlock, updatesRootHash, "U2 follows U1 channel 'Updates' (target=U1 CREATE_CHANNEL root)", t); assertEquals(2, countConnectionsByOwner(u2, u1), @@ -230,28 +232,29 @@ public class IT_03_AddBlock_NoAuth { // 4) FRIEND взаимно (на HEADER) sendConnection(sender1, st1, MsgSubType.CONNECTION_CLOSE_FRIEND, - bch2, u2HeaderBlock, u2HeaderHash, + u2, u2HeaderBlock, u2HeaderHash, "U1 -> U2: FRIEND", t); sendConnection(sender2, st2, MsgSubType.CONNECTION_CLOSE_FRIEND, - bch1, u1HeaderBlock, u1HeaderHash, + u1, u1HeaderBlock, u1HeaderHash, "U2 -> U1: FRIEND", t); // 5) CONTACT несколько sendConnection(sender1, st1, MsgSubType.CONNECTION_CONTACT, - bch2, u2HeaderBlock, u2HeaderHash, + u2, u2HeaderBlock, u2HeaderHash, "U1 -> U2: CONTACT", t); sendConnection(sender2, st2, MsgSubType.CONNECTION_CONTACT, - bch1, u1HeaderBlock, u1HeaderHash, + u1, u1HeaderBlock, u1HeaderHash, "U2 -> U1: CONTACT", t); // ========================= // USER2 REPLY (ответ в чужой канал) // ========================= { - sender2.send(TextBody.newReply( - bch1, + sender2.send(new TextReplyBody( + MsgSubType.TEXT_REPLY, + u1, 1, newsPost0Block, newsPost0Hash, "U2: reply to U1 News post #0 (cross-chain)" @@ -264,7 +267,7 @@ public class IT_03_AddBlock_NoAuth { ChainState st3 = new ChainState(); AddBlockSender sender3 = new AddBlockSender(ws, st3, u3, bch3, TestConfig.getBlockchainPrivatKey(u3)); - sender3.send(new HeaderBody(u3), t); + sender3.send(new HeaderBody(u3, Ed25519Util.derivePublicKey(TestConfig.getBlockchainPrivatKey(u3))), t); assertTrue(st3.hasHeader()); int u3HeaderBlock = 0; @@ -273,12 +276,12 @@ public class IT_03_AddBlock_NoAuth { // U1 -> U3: CONTACT sendConnection(sender1, st1, MsgSubType.CONNECTION_CONTACT, - bch3, u3HeaderBlock, u3HeaderHash, + u3, u3HeaderBlock, u3HeaderHash, "U1 -> U3: CONTACT", t); // 6) U2 отписывается только от News sendConnection(sender2, st2, MsgSubType.CONNECTION_UNFOLLOW, - bch1, newsRootBlock, newsRootHash, + u1, newsRootBlock, newsRootHash, "U2 unfollows U1 channel 'News'", t); assertEquals(1, countConnectionsByOwner(u2, u1), @@ -292,7 +295,7 @@ public class IT_03_AddBlock_NoAuth { // 7) U1 убирает U2 из контактов (UNCONTACT) sendConnection(sender1, st1, MsgSubType.CONNECTION_UNCONTACT, - bch2, u2HeaderBlock, u2HeaderHash, + u2, u2HeaderBlock, u2HeaderHash, "U1 -> U2: UNCONTACT", t); r.ok("IT_03 сценарий блоков + connections выполнен"); @@ -313,7 +316,7 @@ public class IT_03_AddBlock_NoAuth { private static void sendConnection(AddBlockSender sender, ChainState st, short subType, - String toBlockchainName, + String toLogin, int toBlockNumber, byte[] toBlockHash32, String logNote, @@ -321,23 +324,20 @@ public class IT_03_AddBlock_NoAuth { if (TestConfig.DEBUG()) { TestLog.info("CONNECTION: subType=" + (subType & 0xFFFF) - + " to=" + toBlockchainName + + " to=" + toLogin + " targetBlock=" + toBlockNumber + " note=" + logNote); } var ln = st.nextLineByType(ChainState.TYPE_CONNECTION); - // КОНСТРУКТОР ИЗ ТВОЕГО КОДА: - // ConnectionBody(int lineCode, int prevLineNumber, byte[] prevLineHash32, int thisLineNumber, - // short subType, String toBlockchainName, int toBlockGlobalNumber, byte[] toBlockHash32) sender.send(new ConnectionBody( - 0, // lineCode для connection линии ln.prevLineNumber, ln.prevLineHash32, ln.thisLineNumber, subType, - toBlockchainName, + toLogin, + 1, toBlockNumber, toBlockHash32 ), timeout); diff --git a/SHiNE-server/src/test/java/test/it/cases/SeedDataPopulationHelper.java b/SHiNE-server/src/test/java/test/it/cases/SeedDataPopulationHelper.java index b08e3cb9..4ce65a3c 100644 --- a/SHiNE-server/src/test/java/test/it/cases/SeedDataPopulationHelper.java +++ b/SHiNE-server/src/test/java/test/it/cases/SeedDataPopulationHelper.java @@ -3,7 +3,7 @@ package test.it.cases; import blockchain.MsgSubType; import blockchain.body.ConnectionBody; import blockchain.body.HeaderBody; -import blockchain.body.TextBody; +import blockchain.body.TextLineBody; import blockchain.body.UserParamBody; import test.it.blockchain.AddBlockSender; import test.it.blockchain.ChainState; @@ -112,11 +112,13 @@ public final class SeedDataPopulationHelper { AddBlockSender sender = senderFor(login); ChainState state = stateFor(login); ChainState.NextLine line = state.nextTextLineByCode(0); - sender.send(TextBody.newPost( + sender.send(new TextLineBody( line.lineCode, line.prevLineNumber, line.prevLineHash32, line.thisLineNumber, + MsgSubType.TEXT_POST, + null, null, null, null, cleanText ), timeout); } @@ -130,7 +132,6 @@ public final class SeedDataPopulationHelper { ChainState state = stateFor(login); ChainState.NextLine line = state.nextLineByType(ChainState.TYPE_USER_PARAM); sender.send(new UserParamBody( - 0, line.prevLineNumber, line.prevLineHash32, line.thisLineNumber, @@ -146,12 +147,12 @@ public final class SeedDataPopulationHelper { ChainState.NextLine line = state.nextLineByType(ChainState.TYPE_CONNECTION); sender.send(new ConnectionBody( - 0, line.prevLineNumber, line.prevLineHash32, line.thisLineNumber, relationSubType, - bch(to), + to, + 1, 0, targetHeaderHash ), timeout); @@ -160,7 +161,7 @@ public final class SeedDataPopulationHelper { private void initHeader(String login) { ChainState state = new ChainState(); AddBlockSender sender = new AddBlockSender(ws, state, login, bch(login), keys.blockchainPrivate32); - sender.send(new HeaderBody(login), timeout); + sender.send(new HeaderBody(login, Ed25519Util.derivePublicKey(keys.blockchainPrivate32)), timeout); byte[] headerHash = state.getHash32(0); if (headerHash == null || headerHash.length != 32) { diff --git a/TODO/PUBLIC_ATTACHMENTS_TODO.md b/TODO/PUBLIC_ATTACHMENTS_TODO.md new file mode 100644 index 00000000..c74f2e3e --- /dev/null +++ b/TODO/PUBLIC_ATTACHMENTS_TODO.md @@ -0,0 +1,213 @@ +# TODO — публичные вложенные файлы + +## Цель + +Довести публичную раздачу вложений до production-схемы: +сервер SHiNE остаётся origin-хранилищем файлов, а Cloudflare используется перед ним +для HTTPS, кэширования и CDN. + +Отдельный CDN-сервис на данном этапе не требуется, если Cloudflare нормально кэширует +ответы серверного file endpoint. + +--- + +## 1. Настроить Cloudflare + +- Подключить домен/поддомен для публичных вложений. +- Проксировать file endpoint через Cloudflare. +- Проверить HTTPS. +- Настроить Cache Rules для публичных неизменяемых файлов. +- По возможности использовать длинный TTL для файлов, адресуемых по хэшу/ID. +- Проверить корректную работу Range-запросов и ответов `206 Partial Content`. +- Не кэшировать служебные API-ответы и ошибки, которые кэшировать не нужно. + +### Предпочтительная схема + +Client +→ Cloudflare +→ SHiNE server file endpoint +→ локальное файловое хранилище сервера + +То есть отдельную CDN-реализацию внутри SHiNE делать не обязательно: +сервер должен корректно отдавать файлы, а Cloudflare занимается внешним кэшем/CDN. + +--- + +## 2. Полноценная HTTP-отдача файлов + +Для публичного file endpoint реализовать/проверить: + +### GET + +- Полная отдача файла. +- Правильный `Content-Type`. +- Правильный `Content-Length`. +- `Content-Disposition`, где это необходимо. +- Стабильное имя/ID файла в URL. +- Корректный `404`, если файла нет. + +### HEAD + +- Те же HTTP-заголовки, что и для `GET`, но без тела файла. +- Нужен для проверки размера, типа и существования файла. +- Не должен читать весь файл в память. + +### Range requests + +Поддержать: + +`Range: bytes=start-end` + +и ответ: + +`206 Partial Content` + +с корректными: + +- `Accept-Ranges: bytes` +- `Content-Range` +- `Content-Length` + +Также обработать: + +- `bytes=N-` +- при необходимости `bytes=-N` +- некорректный диапазон → `416 Range Not Satisfiable` + +Важно: сервер не должен загружать весь большой файл в RAM ради выдачи небольшого диапазона. + +--- + +## 3. Докачка файлов + +Клиент должен иметь возможность продолжить загрузку после обрыва. + +Сценарий: + +1. Клиент уже скачал первые N байт. +2. Повторный запрос отправляется с: + `Range: bytes=N-` +3. Сервер возвращает остаток через `206 Partial Content`. + +Желательно дополнительно использовать: + +- `ETag` +- `Last-Modified` +- `If-Range` + +Это позволит убедиться, что докачивается та же версия файла. + +--- + +## 4. Кэширование + +Для неизменяемых публичных файлов желательно: + +- адресовать файл стабильным ID/хэшем; +- после публикации не изменять содержимое под тем же ID; +- отдавать подходящий `Cache-Control`; +- использовать `ETag`. + +Если содержимое изменилось — лучше создавать новый объект/ID, а не менять содержимое старого URL. + +--- + +## 5. Безопасность и корректность + +Проверить: + +- защиту от `../` и path traversal; +- невозможность запросить произвольный файл сервера; +- ограничения допустимых директорий; +- корректность MIME-type; +- лимиты размера; +- отсутствие передачи внутренних filesystem-path клиенту; +- логирование подозрительных и битых запросов. + +--- + +## 6. Garbage Collector / проверка файлов — позже + +Добавить фоновый или периодический сборщик мусора. + +Он должен уметь: + +### Проверять физические файлы + +- существует ли файл; +- соответствует ли размер; +- соответствует ли SHA-256/ожидаемый hash; +- не повреждён ли файл; +- есть ли для него запись в БД. + +### Проверять БД + +- есть ли физический файл для каждой актуальной записи; +- нет ли записей, указывающих на отсутствующие файлы. + +### Находить orphan-файлы + +Файлы, которые лежат на диске, но больше ни на что не ссылаются. + +На первом этапе безопаснее: + +- только находить; +- писать отчёт; +- ничего автоматически не удалять. + +Позже можно добавить grace period: +orphan найден → помечен → повторно проверен через несколько дней → только потом допускается удаление. + +### Никогда сразу не удалять + +До появления уверенной reference-модели GC должен работать в режиме аудита. + +--- + +## 7. Метрики и обслуживание — желательно позже + +Добавить базовые метрики: + +- объём файлов на диске; +- количество файлов; +- число GET / HEAD / Range запросов; +- объём исходящего трафика; +- доля `206`; +- `404` / `416`; +- ошибки чтения файлов; +- количество orphan/corrupted файлов по результатам GC. + +--- + +## Приоритет реализации + +### Сначала + +1. `GET` +2. `HEAD` +3. `Range` / `206 Partial Content` +4. нормальная докачка +5. `ETag` / `If-Range` +6. Cloudflare перед file endpoint +7. Cache Rules + +### Затем + +8. мониторинг +9. проверка целостности файлов +10. garbage collector в audit-only режиме +11. автоматическая очистка только после отдельного решения + +--- + +## Основное архитектурное решение + +На текущем этапе отдельный собственный CDN-слой SHiNE не нужен. + +**SHiNE server = origin файлов** + +**Cloudflare = внешний CDN/cache** + +Сервер должен корректно поддерживать стандартный HTTP для больших файлов и частичной выдачи. +Тогда браузеры, загрузчики и Cloudflare смогут нормально работать с файлами без отдельного +протокола SHiNE для скачивания. diff --git a/TODO/Близкое/Переработать_authority_Solana_PDA_через_Recovery_key.md b/TODO/Близкое/Переработать_authority_Solana_PDA_через_Recovery_key.md new file mode 100644 index 00000000..20c34cbb --- /dev/null +++ b/TODO/Близкое/Переработать_authority_Solana_PDA_через_Recovery_key.md @@ -0,0 +1,48 @@ +# Переработать authority Solana PDA через Recovery key + +## Статус + +**Не делать в текущем patch.** Solana smart contract и существующие правила `shine_users` пока остаются без изменений. + +Причина: текущий контракт рабочий, а окончательная модель прав ещё требует отдельного решения и тестов. Не смешивать эту переработку с UI/кошельками/хранением ключей. + +## Текущая модель + +- обычные `update_user_pda` авторизуются активным `blockchain key`; +- полная ротация root + client + blockchain использует старый `root/recovery key` как дополнительное recovery-разрешение; +- новый blockchain key подписывает новое состояние по текущему протоколу; +- увеличение платного лимита также проходит через текущую схему обычного update. + +## Желаемое направление + +Recovery key логически должен быть главным ключом для критического управления аккаунтом, например: + +- смена recovery/root key; +- смена blockchain key / создание нового fork; +- смена client key; +- смена access server; +- изменение критических настроек серверов/доступа. + +При этом простое **увеличение оплаченного лимита** не должно заставлять пользователя вводить пароль и временно восстанавливать Recovery private key. + +## Предпочтительный вариант для исследования + +Не исключать отдельные поля PDA из цифровой подписи. Подпись должна покрывать всё авторизуемое состояние целиком. + +Вместо этого разделить Solana-инструкции по полномочиям: + +1. `top_up_limit(...)` — узкая экономическая инструкция, которая умеет только увеличить `paid_limit`/`additional_limit` и физически не может менять identity, ключи или серверы. Recovery не требуется. +2. `rotate_keys(...)` / критический `update_account(...)` — изменение root/client/blockchain identity, требует Recovery-authority; отдельно решить, нужна ли совместная подпись текущего blockchain key. +3. `update_servers(...)` — критические server/access-server изменения, вероятно требуют Recovery-authority; окончательное правило зафиксировать после threat-model. + +Возможная усиленная схема для критических изменений: текущий blockchain key + текущий Recovery key подписывают один и тот же hash полного нового состояния, а при ротации новый blockchain key дополнительно доказывает владение новым ключом. + +## Обязательные тесты перед изменением контракта + +- compromised blockchain key не может захватить identity без Recovery; +- Recovery может безопасно восстановить аккаунт после компрометации blockchain key; +- top-up лимита не может изменить ни один identity/server field; +- replay старой подписи невозможен; +- смена любого ключа атомарна; +- fee payer не обязан совпадать с Recovery key; +- crash/retry не оставляет PDA в промежуточном состоянии. diff --git a/VERSION.properties b/VERSION.properties index aba3165e..a7adead6 100644 --- a/VERSION.properties +++ b/VERSION.properties @@ -1,2 +1,2 @@ -client.version=1.14.0 -server.version=1.12.0 +client.version=1.15.0 +server.version=1.13.0 diff --git a/deploy/PUBLIC_FILES_CADDY_CLOUDFLARE.md b/deploy/PUBLIC_FILES_CADDY_CLOUDFLARE.md new file mode 100644 index 00000000..4c2662f4 --- /dev/null +++ b/deploy/PUBLIC_FILES_CADDY_CLOUDFLARE.md @@ -0,0 +1,164 @@ +# Public files: Caddy + Cloudflare на том же домене + +Цель: использовать один домен `shineup.me`, но обрабатывать `/files/` отдельно от UI/API. + +- `PUT /files/` -> Java SHiNE server, потому что нужна session-signature и проверка SHA-256; +- `GET/HEAD /files/` -> Caddy напрямую с диска; +- `/ws`, `/dm-files/*` и остальные маршруты работают как раньше; +- Cloudflare кэширует только `/files/*`. + +## 1. Один каталог для Java и Caddy + +Например: + +```text +/home/player/shine-public-files +``` + +Java запускается с: + +```text +-Dpublic.files.storageDir=/home/player/shine-public-files +``` + +`deploy/scripts/deploy_server.sh` поддерживает переменную: + +```bash +REMOTE_PUBLIC_FILES_DIR=/home/player/shine-public-files +``` + +Caddy должен иметь право прохода к родительским каталогам и чтения файлов. `PublicFileServlet` после успешного PUT выставляет финальному файлу права `0644` на POSIX-системах, но права родительского каталога всё равно нужно проверить. Например: + +```bash +chmod 755 /home/player/shine-public-files +``` + +Если `/home/player` закрыт для пользователя `caddy`, используйте каталог в `/srv`/`/var/lib` или настройте группу/ACL вместо расширения доступа ко всему home. + +## 2. Caddyfile + +Маршруты `/files/*` должны стоять **до SPA fallback**. + +```caddyfile +shineup.me { + encode zstd gzip + + @publicFilesRead { + method GET HEAD + path_regexp public_file ^/files/[0-9a-f]{64}$ + } + handle @publicFilesRead { + uri strip_prefix /files + root * /home/player/shine-public-files + header { + Cache-Control "public, max-age=31536000, immutable" + Access-Control-Allow-Origin "*" + Cross-Origin-Resource-Policy "cross-origin" + } + file_server + } + + @publicFilesWrite { + method PUT OPTIONS + path /files/* + } + handle @publicFilesWrite { + reverse_proxy 127.0.0.1:7070 + } + + @ws path /ws /ws/* + handle @ws { + reverse_proxy 127.0.0.1:7070 + } + + @dmfiles path /dm-files /dm-files/* + handle @dmfiles { + reverse_proxy 127.0.0.1:7070 + } + + handle { + root * /home/player/SHiNE/shine-ui + try_files {path} /index.html + file_server + header -Etag + header { + Cache-Control "no-store, no-cache, must-revalidate, max-age=0" + Pragma "no-cache" + Expires "0" + } + } +} +``` + +Если используется отдельный `:80` site block, тот же `/files` routing нужно добавить и туда либо перенаправлять HTTP на HTTPS. + +После изменения: + +```bash +sudo caddy validate --config /etc/caddy/Caddyfile +sudo systemctl reload caddy +``` + +## 3. Cloudflare Cache Rules + +### Rule 1: public files + +Условие: + +```text +Hostname equals shineup.me +AND URI Path starts with /files/ +``` + +Настройки: + +```text +Cache eligibility: Eligible for cache +Edge TTL: Override origin / большой TTL (например 1 год) +``` + +URL immutable: новые байты всегда имеют новый SHA-256 и, следовательно, новый URL. Поэтому purge при обновлении файла не нужен. + +### Rule 2: всё остальное + +Чтобы исключить случайное кэширование динамики, можно добавить правило: + +```text +Hostname equals shineup.me +AND URI Path does not start with /files/ +``` + +и выставить: + +```text +Cache eligibility: Bypass cache +``` + +UI дополнительно уже отправляет `Cache-Control: no-store` через Caddy. + +## 4. Проверка + +Загрузить файл через UI, затем проверить: + +```bash +curl -I https://shineup.me/files/ +``` + +Ожидается: + +```text +HTTP/2 200 +cache-control: public, max-age=31536000, immutable +content-length: ... +etag: ... +``` + +При повторных запросах после прогрева Cloudflare в ответе должен появиться соответствующий cache status (`HIT`). + +## 5. Важно + +- сам Java server не должен использоваться как основной download path в production; +- Caddy читает ровно те же файлы, которые записывает Java; +- никакие имена пользователей или MIME не входят в path; +- `/files/` публичен: это вложение публичного сообщения; +- удаление сообщения не должно автоматически удалять объект из `public-files`, потому что тот же SHA-256 может использоваться другими сообщениями или пользователями. diff --git a/deploy/README.md b/deploy/README.md index 77851b69..6df33c88 100644 --- a/deploy/README.md +++ b/deploy/README.md @@ -33,6 +33,7 @@ - `CONFIGURE_TURN_IN_SHINE.md` — как подключить TURN к SHiNE backend. - `SETUP_SERVER_FROM_ZERO.md` — настройка SHiNE-сервера и UI с нуля. - `SETUP_TURN_SERVER.md` — настройка TURN через Caddy/DNS/TLS. +- `PUBLIC_FILES_CADDY_CLOUDFLARE.md` — `/files/` на том же домене: Caddy читает с диска, Cloudflare кэширует только public files. - `AGENT_BOT_CODER_LOCAL_SYSTEMD.md` — локальный systemd-deploy Telegram-бота агента-кодера. - `AGENTS.md` — правила для агента при деплое. diff --git a/deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md b/deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md index e8105a06..05701538 100644 --- a/deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md +++ b/deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md @@ -56,10 +56,12 @@ psql \ -f SHiNE-server/shine-server-db/src/main/resources/postgres/schema_v1.sql ``` +Скрипт предназначен **только для полностью пустой PostgreSQL схемы**. На старой/непустой базе он завершится ошибкой и не выполняет in-place migration. + Скрипт: -- создаёт таблицу версии схемы `db_schema_version`; -- ставит актуальный `schema_version`; +- создаёт жёсткий маркер поколения БД `shine_database_metadata`: `SHiNE_DB_V2`, generation `2`; +- создаёт таблицу версии runtime-схемы `db_schema_version` и ставит `schema_version=29`; - создаёт таблицы sync-модуля Solana users; - создаёт server runtime tables; - создаёт триггеры и функции автоматической актуализации `user_access_servers_current`; @@ -113,3 +115,13 @@ cp /path/to/SHiNE-product/application.properties ./application.properties После обновления `shine_users` серверный модуль `shine-server-solana-users-sync` должен обновляться вместе с программой: текущий codec принимает только PDA 1.2. Legacy PDA 1.0 не мигрируются; тестовые legacy-записи можно закрыть временной инструкцией `close_legacy_pda`. Миграция PostgreSQL v25 добавляет `blockchain_forks_json`. Старые compatibility-колонки продолжают содержать активный (последний) fork, а полный список ключей fork сохраняется отдельно и используется для поиска владельца Arweave-записей по любому историческому blockchain key. + +## PostgreSQL migration v26: key rotation runtime state + +Migration v26 добавляет server-local поля `rotation_status` / `rotation_session_id` в `solana_user_pda_current` и таблицу `key_rotation_sessions`. + +Это локальное состояние длительной смены ключей, а не часть Solana PDA. Solana users sync продолжает обновлять только PDA-поля и не должен затирать rotation-state. После обновления сервера миграция применяется стандартным `DatabaseInitializer` автоматически. + +## Миграции key rotation + +При обновлении сервера DatabaseInitializer последовательно применяет migration v26 (state machine смены ключей) и v27 (отдельные candidate-блоки будущего fork). Ручного создания таблиц не требуется. Candidate-блоки не входят в текущую таблицу `blocks` до финального переключения fork. diff --git a/deploy/scripts/deploy_server.sh b/deploy/scripts/deploy_server.sh index d9be6e23..a24d230f 100755 --- a/deploy/scripts/deploy_server.sh +++ b/deploy/scripts/deploy_server.sh @@ -10,6 +10,7 @@ REMOTE_SERVER_DIR="${REMOTE_SERVER_DIR:?REMOTE_SERVER_DIR is required}" REMOTE_LOGS_DIR="${REMOTE_LOGS_DIR:-$REMOTE_SERVER_DIR/logs}" REMOTE_DATA_DIR="${REMOTE_DATA_DIR:-$REMOTE_SERVER_DIR/data}" REMOTE_DM_FILES_DIR="${REMOTE_DM_FILES_DIR:-}" +REMOTE_PUBLIC_FILES_DIR="${REMOTE_PUBLIC_FILES_DIR:-}" REMOTE_SERVICE_NAME="${REMOTE_SERVICE_NAME:?REMOTE_SERVICE_NAME is required}" SERVER_PORT="${SERVER_PORT:?SERVER_PORT is required}" LOCAL_JAR="${LOCAL_JAR:-$ROOT_DIR/SHiNE-server/build/libs/shine-server.jar}" @@ -55,7 +56,7 @@ Type=simple User=player Group=player WorkingDirectory=$REMOTE_SERVER_DIR -ExecStart=/usr/bin/java -Dserver.port=$SERVER_PORT${REMOTE_DM_FILES_DIR:+ -Ddm.files.storageDir=$REMOTE_DM_FILES_DIR} -jar $REMOTE_SERVER_DIR/shine-server.jar +ExecStart=/usr/bin/java -Dserver.port=$SERVER_PORT${REMOTE_DM_FILES_DIR:+ -Ddm.files.storageDir=$REMOTE_DM_FILES_DIR}${REMOTE_PUBLIC_FILES_DIR:+ -Dpublic.files.enabled=true -Dpublic.files.storageDir=$REMOTE_PUBLIC_FILES_DIR} -jar $REMOTE_SERVER_DIR/shine-server.jar Restart=always RestartSec=3 @@ -63,11 +64,10 @@ RestartSec=3 WantedBy=multi-user.target EOF -if [[ -n "$REMOTE_DM_FILES_DIR" ]]; then - ssh "$REMOTE_HOST" "mkdir -p '$REMOTE_SERVER_DIR' '$REMOTE_DATA_DIR' '$REMOTE_LOGS_DIR' '$REMOTE_DM_FILES_DIR'" -else - ssh "$REMOTE_HOST" "mkdir -p '$REMOTE_SERVER_DIR' '$REMOTE_DATA_DIR' '$REMOTE_LOGS_DIR'" -fi +REMOTE_EXTRA_DIRS="" +[[ -n "$REMOTE_DM_FILES_DIR" ]] && REMOTE_EXTRA_DIRS+=" '$REMOTE_DM_FILES_DIR'" +[[ -n "$REMOTE_PUBLIC_FILES_DIR" ]] && REMOTE_EXTRA_DIRS+=" '$REMOTE_PUBLIC_FILES_DIR'" +ssh "$REMOTE_HOST" "mkdir -p '$REMOTE_SERVER_DIR' '$REMOTE_DATA_DIR' '$REMOTE_LOGS_DIR'$REMOTE_EXTRA_DIRS" rsync -az --timeout=120 "$LOCAL_JAR" "$REMOTE_HOST:$REMOTE_SERVER_DIR/shine-server.jar" rsync -az "$TMP_DIR/$REMOTE_SERVICE_NAME.service" "$REMOTE_HOST:/tmp/$REMOTE_SERVICE_NAME.service" diff --git a/deploy/scripts/deploy_ui.sh b/deploy/scripts/deploy_ui.sh index 279e2605..a9fa1238 100755 --- a/deploy/scripts/deploy_ui.sh +++ b/deploy/scripts/deploy_ui.sh @@ -103,8 +103,9 @@ CADDY_CONFIG_PATH="$(ssh "$REMOTE_HOST" "set -e; \ ROOT_CHECK_OUTPUT="$(ssh "$REMOTE_HOST" "set -euo pipefail; \ cfg='$CADDY_CONFIG_PATH'; \ site='$EXPECTED_CADDY_SITE'; \ - sudo awk -v site=\"\$site\" ' - BEGIN { in_site=0; depth=0; root_line=\"\"; root_lineno=0; have_site=0; } + expected_root='$EXPECTED_CADDY_UI_ROOT'; \ + sudo awk -v site=\"\$site\" -v expected_root=\"\$expected_root\" ' + BEGIN { in_site=0; depth=0; roots=\"\"; have_site=0; have_expected=0; } { line=\$0; trimmed=line; @@ -119,9 +120,12 @@ ROOT_CHECK_OUTPUT="$(ssh "$REMOTE_HOST" "set -euo pipefail; \ next; } } else { - if (trimmed ~ /^root[[:space:]]+\\*[[:space:]]+/ && root_line == \"\") { - root_line=line; - root_lineno=NR; + if (trimmed ~ /^root[[:space:]]+\\*[[:space:]]+/) { + root_entry=NR \":\" line; + roots = roots (roots == \"\" ? \"\" : \"\\n\") root_entry; + if (line ~ expected_root) { + have_expected=1; + } } opens=gsub(/\\{/, \"{\", line); closes=gsub(/\\}/, \"}\", line); @@ -136,11 +140,15 @@ ROOT_CHECK_OUTPUT="$(ssh "$REMOTE_HOST" "set -euo pipefail; \ print \"SITE_NOT_FOUND\"; exit 0; } - if (root_line == \"\") { + if (roots == \"\") { print \"ROOT_NOT_FOUND\"; exit 0; } - print root_lineno \":\" root_line; + if (have_expected) { + print \"OK\"; + exit 0; + } + print roots; } ' \"\$cfg\"")" @@ -160,8 +168,9 @@ elif [[ "$ROOT_CHECK_OUTPUT" == "ROOT_NOT_FOUND" ]]; then exit 1 fi echo "WARN: proceeding due to ALLOW_CADDY_MISMATCH=1" -elif [[ "$ROOT_CHECK_OUTPUT" != *"$EXPECTED_CADDY_UI_ROOT"* ]]; then - echo "ERROR: Caddy root mismatch for site $EXPECTED_CADDY_SITE. Found: $ROOT_CHECK_OUTPUT" >&2 +elif [[ "$ROOT_CHECK_OUTPUT" != "OK" ]]; then + echo "ERROR: Caddy root mismatch for site $EXPECTED_CADDY_SITE. Found roots:" >&2 + echo "$ROOT_CHECK_OUTPUT" >&2 echo "Caddy config: $CADDY_CONFIG_PATH" >&2 echo "Expected path fragment: $EXPECTED_CADDY_UI_ROOT" >&2 if [[ "$ALLOW_CADDY_MISMATCH" != "1" ]]; then diff --git a/deploy/scripts/test_t1_server.sh b/deploy/scripts/test_t1_server.sh index f61c5d91..5de73bc8 100755 --- a/deploy/scripts/test_t1_server.sh +++ b/deploy/scripts/test_t1_server.sh @@ -5,6 +5,7 @@ REMOTE_HOST="player@t1.shineup.me" \ TARGET_DOMAIN="t1.shineup.me" \ REMOTE_SERVER_DIR="/home/player/t1/server" \ REMOTE_DM_FILES_DIR="/home/player/test-dm-files" \ +REMOTE_PUBLIC_FILES_DIR="/home/player/test-public-files" \ REMOTE_SERVICE_NAME="shine-t1" \ SERVER_PORT="7101" \ bash "$(dirname "$0")/deploy_server.sh" diff --git a/deploy/scripts/test_t2_server.sh b/deploy/scripts/test_t2_server.sh index 04c1a151..408b96a4 100755 --- a/deploy/scripts/test_t2_server.sh +++ b/deploy/scripts/test_t2_server.sh @@ -5,6 +5,7 @@ REMOTE_HOST="player@t2.shineup.me" \ TARGET_DOMAIN="t2.shineup.me" \ REMOTE_SERVER_DIR="/home/player/t2/server" \ REMOTE_DM_FILES_DIR="/home/player/test-dm-files" \ +REMOTE_PUBLIC_FILES_DIR="/home/player/test-public-files" \ REMOTE_SERVICE_NAME="shine-t2" \ SERVER_PORT="7102" \ bash "$(dirname "$0")/deploy_server.sh" diff --git a/deploy/scripts/test_t3_server.sh b/deploy/scripts/test_t3_server.sh index 430bea9c..355e7470 100755 --- a/deploy/scripts/test_t3_server.sh +++ b/deploy/scripts/test_t3_server.sh @@ -5,6 +5,7 @@ REMOTE_HOST="player@t3.shineup.me" \ TARGET_DOMAIN="t3.shineup.me" \ REMOTE_SERVER_DIR="/home/player/t3/server" \ REMOTE_DM_FILES_DIR="/home/player/test-dm-files" \ +REMOTE_PUBLIC_FILES_DIR="/home/player/test-public-files" \ REMOTE_SERVICE_NAME="shine-t3" \ SERVER_PORT="7103" \ bash "$(dirname "$0")/deploy_server.sh" diff --git a/deploy/scripts/test_t4_server.sh b/deploy/scripts/test_t4_server.sh index 0e603082..2a07aa47 100755 --- a/deploy/scripts/test_t4_server.sh +++ b/deploy/scripts/test_t4_server.sh @@ -5,6 +5,7 @@ REMOTE_HOST="player@t4.shineup.me" \ TARGET_DOMAIN="t4.shineup.me" \ REMOTE_SERVER_DIR="/home/player/t4/server" \ REMOTE_DM_FILES_DIR="/home/player/test-dm-files" \ +REMOTE_PUBLIC_FILES_DIR="/home/player/test-public-files" \ REMOTE_SERVICE_NAME="shine-t4" \ SERVER_PORT="7104" \ bash "$(dirname "$0")/deploy_server.sh" diff --git a/docs/API/03_Session_Management_API.md b/docs/API/03_Session_Management_API.md index 6d304b49..1d08b827 100644 --- a/docs/API/03_Session_Management_API.md +++ b/docs/API/03_Session_Management_API.md @@ -488,3 +488,20 @@ TTL заявки фиксирован на сервере и сейчас все - `404 / PAIRING_NOT_FOUND` - `422 / PAIRING_OF_ANOTHER_REQUESTER` - `422 / PAIRING_NOT_PENDING` + +## 3. `CloseOtherSessions` + +Закрывает все активные сессии текущего пользователя, кроме той, из которой выполнен запрос. + +Запрос: + +```json +{ + "op": "CloseOtherSessions", + "payload": {} +} +``` + +Успешный ответ содержит `closedCount` — число закрытых сессий. Сервер сначала удаляет остальные сессии из `active_sessions`, затем отправляет их активным WebSocket-подключениям событие `SessionRevoked` и закрывает соединения. Текущая сессия не затрагивается. + +Эта же внутренняя операция используется при успешном `KeyRotationStart`: после создания ротации в той же транзакции все остальные сессии пользователя удаляются, а после commit их WebSocket-подключения закрываются. diff --git a/docs/API/04_Add_Block_to_Blockchain_API.md b/docs/API/04_Add_Block_to_Blockchain_API.md index d6fac193..ce2bd0f4 100644 --- a/docs/API/04_Add_Block_to_Blockchain_API.md +++ b/docs/API/04_Add_Block_to_Blockchain_API.md @@ -22,6 +22,7 @@ - `blockchainName` — целевая пользовательская chain; - `blockNumber` — должен совпадать с номером внутри Frame v1 и быть `serverLast + 1`; - `prevBlockHash` — 32-byte SHiNE hash предыдущего Frame в hex; должен совпадать с `prevHash32` внутри Frame и серверной вершиной; +- внутри Frame также обязателен `back32Hash32`: нули для blockNumber < 32, иначе hash Frame блока `blockNumber-32`; - `blockBytesB64` — **полный serialized ANS-104 DataItem** в Base64. Старый формат `preimage + sigMarker + signature` не поддерживается. @@ -31,18 +32,21 @@ - generic Ed25519 signature type `2`; - Ed25519 signature 64 bytes; - owner 32 bytes и равен текущему blockchain public key; -- обязательный тестовый tag `App=test5590`; +- обязательный тестовый tag `App=test5591`; - для channel block — `c=`; +- `TEXT_CHANNEL_DELETE (type=1/subType=92/version=1)` является обычным line-based channel block с пустым text и тем же обязательным `c=`; отдельной операции API для удаления канала нет; - `data` содержит SHiNE Frame v1 (`frameCode=1`). ## Основные ошибки -- `bad_app_tag` — отсутствует/неверен `App=test5590`; +- `bad_app_tag` — отсутствует/неверен `App=test5591`; - `bad_channel_tag` — `c` отсутствует, лишний или не совпадает с canonical slug; - `bad_signature` / `signature_verify_failed` — DataItem не подписан текущим blockchain key; - `bad_block_number` — нарушена последовательность; - `bad_prev_hash` — нарушена SHiNE hash chain; - `bad_block_bytes` — DataItem/Frame не парсится. +- `key_rotation_in_progress` (HTTP/status `423`) — для пользователя уже запущена смена ключей; обычный `AddBlock` временно запрещён до завершения/отмены ротации; +- `key_rotation_check_failed` — сервер не смог проверить локальный rotation status и отклонил запись fail-closed. ## Storage/publish diff --git a/docs/API/06_Channels_Read_API.md b/docs/API/06_Channels_Read_API.md index 33da7c92..9ffb53ca 100644 --- a/docs/API/06_Channels_Read_API.md +++ b/docs/API/06_Channels_Read_API.md @@ -32,6 +32,8 @@ > `unreadCount` для канала считается по подписанному состоянию чтения канала. > Для собственных каналов владельцу всегда возвращается `unreadCount = 0`, чтобы его собственные публикации не становились «новыми» для него самого. > Если для пары `ownerBlockchainName/channelName` ещё нет записи, канал временно считается полностью прочитанным. После появления записи новые публикации увеличивают `unreadCount` до продвижения курсора чтения. +> +> `ListSubscriptionsFeed` технически может возвращать soft-deleted каналы с `channel.deleted=true`, чтобы старые ссылки и selector канала продолжали разрешаться. Обычный UI скрывает такие строки. Для deleted-канала общий unread/counters не учитываются; сама подписка сохраняется. --- @@ -70,6 +72,9 @@ "avaSha256": "0123...", "avaSize": 248193, "metaUpdatedAtMs": 1760000000000, + "deleted": false, + "deletedAtMs": 0, + "deletedBlockNumber": null, "personal": true, "channelRoot": { "blockNumber": 0, "blockHash": "..." } }, @@ -169,6 +174,9 @@ "avaSha256": "0123...", "avaSize": 248193, "metaUpdatedAtMs": 1760000000000, + "deleted": false, + "deletedAtMs": 0, + "deletedBlockNumber": null, "subscribersCount": 128, "channelRoot": { "blockNumber": 123, "blockHash": "..." } }, @@ -223,6 +231,8 @@ } ``` +Для soft-deleted канала `channel.deleted=true`; `deletedAtMs` и `deletedBlockNumber` указывают последний delete-блок. В `metaEvents` delete-блоки возвращаются как `kind: "deleted"`. После новой самостоятельной публикации канал снова активен (`deleted=false`), при этом исторические `deleted` meta-events остаются частью истории. + --- ## 3) GetMessageThread @@ -560,11 +570,13 @@ Returns lightweight public-channel cards for profile counters. `mode` is `owned` { "op": "ListUserProfileChannels", "requestId": "profile-ch-1", - "payload": { "login": "Alice", "mode": "owned", "limit": 100, "offset": 0 } + "payload": { "login": "Alice", "mode": "owned", "includeDeleted": false, "limit": 100, "offset": 0 } } ``` -Channel items contain `ownerLogin`, `slug`, `displayName`, `avatarAr`, `ownerBlockchainName`, `rootBlockNumber`, and `rootBlockHashHex`. +`includeDeleted` необязателен и по умолчанию равен `false`. При `true` ответ включает как активные, так и soft-deleted каналы. + +Channel items contain `ownerLogin`, `slug`, `displayName`, `avatarAr`, `ownerBlockchainName`, `rootBlockNumber`, `rootBlockHashHex`, `deleted`, `deletedAtMs`, and `deletedBlockNumber`. ## Qualified likes (v18) diff --git a/docs/API/09_Operations_Index.md b/docs/API/09_Operations_Index.md index 07553d0b..71d5539f 100644 --- a/docs/API/09_Operations_Index.md +++ b/docs/API/09_Operations_Index.md @@ -29,8 +29,17 @@ | `GetTrustedDeviceLoginStatus` | `03_Session_Management_API.md` | чтение статуса и результата pairing-заявки | | `ListSessions` | `03_Session_Management_API.md` | список активных сессий | | `CloseActiveSession` | `03_Session_Management_API.md` | закрытие активной сессии | +| `CloseOtherSessions` | `03_Session_Management_API.md` | закрыть все остальные сессии текущего пользователя | | `AddBlock` | `04_Add_Block_to_Blockchain_API.md` | добавление блока в блокчейн | | `GetBlockchainBlock` | `04_Add_Block_to_Blockchain_API.md` | чтение одного блока блокчейна | +| `KeyRotationStart` | `19_Key_Rotation_API.md` | начать смену ключей сразу в состоянии `COPYING_CHAIN` | +| `KeyRotationStatus` | `19_Key_Rotation_API.md` | получить текущий этап и прогресс смены ключей | +| `KeyRotationAddBlock` | `19_Key_Rotation_API.md` | добавить подписанный новым blockchain key candidate-блок будущего fork | +| `KeyRotationFinishChain` | `19_Key_Rotation_API.md` | проверить полную публикацию candidate-chain и перевести её в `CHAIN_READY` | +| `KeyRotationRotatePda` | `19_Key_Rotation_API.md` | зафиксировать отправленную Solana-ротацию PDA и ждать подтверждения sync | +| `KeyRotationContinue` | `19_Key_Rotation_API.md` | зафиксировать wallet migration или завершить DM migration после серверной проверки | +| `KeyRotationAbort` | `19_Key_Rotation_API.md` | прервать ротацию до отправки Solana PDA-ротации | +| `GetMyBlockchain` | `20_Get_My_Blockchain_API.md` | постранично читать текущую активную собственную цепочку для аудита и выбора fork point | | `ServerHello` | `16_Server_Connection_Pool_API.md` | объявление server-to-server соединения и возможностей peer без криптографической проверки | | `Ping` | `05_Technical_Requests_API.md` | keep-alive | | `GetServerInfo` | `05_Technical_Requests_API.md` | публичная информация о сервере | @@ -68,7 +77,8 @@ | `ReceiveIncomingMessage` | `12_Direct_Messages_Push_Calls_API.md` | внутренняя доставка входящего DM-блока на единственный сервер получателя | | `DeleteMessage` | `12_Direct_Messages_Push_Calls_API.md` | tombstone одного личного сообщения у обеих сторон | | `DeleteConversation` | `12_Direct_Messages_Push_Calls_API.md` | tombstone удаления истории переписки | -| `GetDirectMessages` | `12_Direct_Messages_Push_Calls_API.md` | постраничная загрузка истории личного диалога | +| `GetDirectMessages` | `12_Direct_Messages_Push_Calls_API.md` | постраничная загрузка истории личного диалога; опциональный фильтр `reencryptedBeforeMs` | +| `ReencryptDirectMessage` | `12_Direct_Messages_Push_Calls_API.md` | сохранить локальную перешифрованную type=1/2 копию без federation | | `AckSessionDelivery` | `12_Direct_Messages_Push_Calls_API.md` | подтверждение доставки в сессию | | `CallInviteBroadcast` | `12_Direct_Messages_Push_Calls_API.md` | broadcast приглашения к звонку | | `CallSignalToSession` | `12_Direct_Messages_Push_Calls_API.md` | сигнал звонка в конкретную сессию | @@ -81,5 +91,6 @@ - Межсерверные DM-операции пока доверяют `sourceServerLogin`; отдельная межсерверная авторизация запланирована позднее. - `ServerHello` пока принимает заявленный `serverLogin` на доверии и не является криптографической аутентификацией. - HTTP endpoints зашифрованных DM-файлов (`PUT/GET/HEAD/OPTIONS /dm-files/{fileId}`) не являются WebSocket `op` и описаны отдельно в `18_DM_File_Storage_API.md`. +- HTTP endpoints публичных content-addressed файлов (`PUT/GET/HEAD/OPTIONS /files/{sha256}`) также не являются WebSocket `op` и описаны отдельно в `21_Public_File_Storage_API.md`. - Классы `Net_MarkChannelMessagesSeen_*` существуют в коде, но операция `MarkChannelMessagesSeen` не зарегистрирована в `JsonHandlerRegistry`, поэтому в публичный список API не входит. - HTTP debug endpoints из `src/main/java/server/debug/` не входят в этот индекс WebSocket `op`; они описаны отдельно в `13_HTTP_Debug_API.md`. diff --git a/docs/API/12_Direct_Messages_Push_Calls_API.md b/docs/API/12_Direct_Messages_Push_Calls_API.md index e0c2b342..b85e1ace 100644 --- a/docs/API/12_Direct_Messages_Push_Calls_API.md +++ b/docs/API/12_Direct_Messages_Push_Calls_API.md @@ -367,3 +367,23 @@ signed-блока проверяется всегда. Официальный UI - сервер хранит последнюю применённую версию контентного сообщения по правилу `revisionTimeMs`, а при равенстве — по `reencryptedAtMs` - если сервер уже знает tombstone удаления переписки и получает старое сообщение до этой границы, он перерассылает известный `DeleteConversation` на `access_servers` обеих сторон - HTTP endpoints для DM-файлов сейчас отсутствуют + +## Перешифровка локальных DM при смене client key + +`GetDirectMessages` поддерживает необязательный параметр `reencryptedBeforeMs`. +Если он больше нуля, сервер возвращает только `type=1/2` локальные копии диалога, которые были сохранены не позже указанного cutoff (`created_at_ms <= reencryptedBeforeMs`) и ещё не прошли эту миграцию (`reencryptedAtMs < reencryptedBeforeMs`). Обычный запрос без параметра работает как раньше. + +Для сохранения локальной перешифрованной копии используется операция `ReencryptDirectMessage`: + +```json +{ + "op": "ReencryptDirectMessage", + "payload": { + "blobB64": "..." + } +} +``` + +Операция разрешена только авторизованному владельцу на активном этапе `MESSAGE_MIGRATION`. Принимаются только `type=1/2`; `reencryptedAtMs` обязан совпадать с временем входа текущей rotation в `MESSAGE_MIGRATION` (в текущем состоянии это `updatedAtMs`). Для `type=1` владельцем считается `toLogin`, для `type=2` — `fromLogin`. + +`ReencryptDirectMessage` обновляет только уже существующую локальную копию. Он не создаёт federation/delivery-задачу, не посылает push и не отправляет сообщение на сервер собеседника. diff --git a/docs/API/19_Key_Rotation_API.md b/docs/API/19_Key_Rotation_API.md new file mode 100644 index 00000000..afc7aa1d --- /dev/null +++ b/docs/API/19_Key_Rotation_API.md @@ -0,0 +1,331 @@ +# Key Rotation API + +> Протокольная семантика fork и target-ссылок: `docs/Blockchain/18_KEY_ROTATION_AND_FORK_TARGETS.md`. +> Физические fork имеют номера только `001..999`; из `*-999` следующая ротация blockchain key запрещена. + +Этот раздел описывает публичные JSON/WebSocket операции мастера смены ключей пользователя. + +Публично доступны: + +- `KeyRotationStart` +- `KeyRotationStatus` +- `KeyRotationAddBlock` +- `KeyRotationFinishChain` +- `KeyRotationRotatePda` +- `KeyRotationContinue` +- `KeyRotationAbort` + +После `PDA_ROTATED` отдельный фоновый worker автоматически переводит ротацию в `REBUILDING_SERVER`, делает новую candidate-chain единственной рабочей цепочкой PostgreSQL и затем переводит процесс в `WALLET_MIGRATION`. + +## Общие правила + +- операции доступны только авторизованному LOCAL-пользователю своего access server; +- login берётся из авторизованной сессии и не передаётся в payload; +- приватные ключи и пароли серверу не передаются никогда; +- в БД сохраняются только старые/новые публичные ключи; +- первая серверная запись появляется сразу в состоянии `COPYING_CHAIN`; состояния `PREPARING` в БД нет; +- во время `KeyRotationStart` сервер захватывает тот же per-blockchain lock, что использует обычный `AddBlock`, и фиксирует непротиворечивый source tip. + +## `KeyRotationStart` + +Создаёт новую серверную сессию ротации. + +### Request + +```json +{ + "op": "KeyRotationStart", + "requestId": "kr-1", + "payload": { + "newRootKey": "", + "newBlockchainKey": "", + "newClientKey": "", + "forkFromBlock": 120, + "forkFromHash": "<64 hex>", + "reasonCode": 1, + "comment": "Плановая смена пароля" + } +} +``` + +`reasonCode`: + +1. обычная ротация; +2. возможная компрометация; +3. подтверждённая компрометация / rollback; +4. recovery. + +Сервер самостоятельно берёт из текущего PDA: + +- `oldRootKey`; +- `oldBlockchainKey`; +- `oldClientKey`; +- текущий `sourceBlockchainName`. + +Также сервер самостоятельно фиксирует текущий tip цепочки. Клиент не может подменить эти значения в запросе. + +`forkFromBlock/forkFromHash` обязаны указывать на реально существующий блок текущей активной цепочки. + +Новые root/blockchain/client keys должны быть валидными 32-байтовыми публичными ключами, отличаться от соответствующих старых ключей и друг от друга. + +После успеха создаётся `key_rotation_sessions` со статусом `COPYING_CHAIN`. В сегментированной модели `progressTotal = 1`: публикуется только один новый `TECH_FORK` с номером `forkFromBlock + 1`; старый префикс `0..forkFromBlock` не перепубликуется. + +### Success response + +Ответ использует тот же payload состояния, что и `KeyRotationStatus`. + +## `KeyRotationStatus` + +Возвращает текущее состояние ротации авторизованного пользователя. + +### Request + +```json +{ + "op": "KeyRotationStatus", + "requestId": "kr-status-1", + "payload": {} +} +``` + +Если активной ротации нет: + +```json +{ + "op": "KeyRotationStatus", + "requestId": "kr-status-1", + "status": 200, + "ok": true, + "payload": { + "rotationStatus": "NONE" + } +} +``` + +Если ротация есть, payload содержит: + +- `rotationSessionId`; +- `rotationStatus`; +- `sourceBlockchainName` / `candidateBlockchainName`; +- старые и новые публичные root/blockchain/client keys; +- `forkFromBlock` / `forkFromHash`; +- `sourceTipBlock` / `sourceTipHash`; +- `reasonCode` / `comment`; +- `progressCurrent` / `progressTotal`; +- `pdaRotationSignature` (когда появится на последующем этапе); +- `walletMigrationStatus`; +- `messageMigrationStatus`; +- `lastError` / `retryCount`; +- `createdAtMs` / `updatedAtMs`. + +Любая авторизованная сессия пользователя может читать этот статус. Состояние ротации принадлежит аккаунту, а не конкретному WebSocket-сеансу. + + +## `KeyRotationAddBlock` + +Принимает единственный ANS-104 `TECH_FORK` будущего сегмента на этапе `COPYING_CHAIN`. Candidate-блок хранится отдельно от обычной таблицы `blocks`, поэтому до переключения fork он **не создаёт лайки, ответы, каналы, связи и другие materialized effects**. + +### Request + +```json +{ + "op": "KeyRotationAddBlock", + "requestId": "kr-block-1", + "payload": { + "blockNumber": "", + "prevBlockHash": "", + "blockBytesB64": "<полный ANS-104 TECH_FORK DataItem в Base64>" + } +} +``` + +Правила: + +- операция доступна только при `rotationStatus=COPYING_CHAIN`; +- принимается только один `TECH_FORK` с номером `forkFromBlock + 1`; старые блоки `0..forkFromBlock` повторно не загружаются; +- каждый DataItem обязан быть подписан `newBlockchainKey`; +- последний блок обязан быть `TECH_FORK`, а его parent key, fork point, старый tip, reason/comment и число отброшенных блоков должны совпадать с `KeyRotationStart`; +- повтор уже принятого идентичного блока безопасен и возвращает success; другой DataItem/hash на том же номере возвращает conflict; +- candidate-блоки попадают в отдельную очередь Arweave/Turbo publisher-а и имеют приоритет перед обычными блоками; +- `progressCurrent` увеличивается **только после фактической успешной публикации** DataItem в Arweave/Turbo. Поэтому `KeyRotationStatus` показывает реальный прогресс публикации, а не только приём сервером. + +### Основные ошибки + +- `KEY_ROTATION_NOT_COPYING` — ротация не находится в `COPYING_CHAIN`; +- `KEY_ROTATION_BLOCK_OUT_OF_ORDER` — передан номер, отличный от `forkFromBlock + 1`; +- `KEY_ROTATION_BLOCK_CONFLICT` — на этом номере уже сохранён другой candidate-блок; +- `KEY_ROTATION_BAD_SIGNATURE` — DataItem подписан не новым blockchain key; +- `KEY_ROTATION_TECH_FORK_REQUIRED` — вместо финального `TECH_FORK` передан другой блок; +- ошибки `KEY_ROTATION_TECH_FORK_*` — поля `TECH_FORK` не соответствуют зафиксированной rotation session. + +## Основные ошибки `KeyRotationStart` + +- `AUTH_REQUIRED` — нет авторизованной сессии; +- `KEY_ROTATION_ALREADY_ACTIVE` — для login уже выполняется ротация; +- `KEY_ROTATION_BAD_FIELDS` — некорректные public keys/hash; +- `KEY_ROTATION_BAD_NEW_KEYS` — ключи не изменились либо новые ключи совпадают друг с другом; +- `KEY_ROTATION_BAD_REASON` — reason вне диапазона `1..4`; +- `KEY_ROTATION_COMMENT_TOO_LONG` — комментарий больше 1024 UTF-8 байт; +- `KEY_ROTATION_BAD_FORK_POINT` — неверная точка fork; +- `KEY_ROTATION_FORK_BLOCK_NOT_FOUND` — выбранный блок отсутствует; +- `KEY_ROTATION_FORK_HASH_MISMATCH` — переданный hash не совпадает с сервером; +- `KEY_ROTATION_SESSION_STALE` — авторизованная сессия содержит уже неактуальный blockchainName. + + +## `KeyRotationFinishChain` + +Финализирует публикацию candidate `TECH_FORK`. Операция **не меняет PDA** и не переключает активную цепочку пользователя: она только доказывает, что новый сегмент уже имеет опубликованную точку входа в Arweave/Turbo. + +### Request + +```json +{ + "op": "KeyRotationFinishChain", + "requestId": "kr-finish-chain-1", + "payload": {} +} +``` + +Перед переходом в `CHAIN_READY` сервер повторно проверяет: + +- существует ровно один candidate-блок, соответствующий `progressTotal = 1`; +- каждый candidate-блок уже подтверждён Arweave/Turbo publisher-ом; +- `blockHash` и `DataItem id` совпадают с сохранёнными значениями; +- каждый DataItem подписан `newBlockchainKey`; +- единственный candidate-блок является корректным `TECH_FORK`, его `prevHash` равен hash выбранного fork point, а body повторяет зафиксированные parent key, fork point, parent tip, reason/comment и число отброшенных блоков. + +Только после успешной финальной проверки выполняется: + +`COPYING_CHAIN -> CHAIN_READY`. + +Повторный `KeyRotationFinishChain`, когда ротация уже находится в `CHAIN_READY`, идемпотентно возвращает success. Это позволяет безопасно вызывать операцию из нескольких сессий или повторить её после потери ответа. + +### Основные ошибки + +- `KEY_ROTATION_NOT_ACTIVE` — активная ротация отсутствует; +- `KEY_ROTATION_NOT_COPYING` — текущий этап уже не позволяет завершать candidate-chain; +- `KEY_ROTATION_CHAIN_INCOMPLETE` — сервер получил не все candidate-блоки; +- `KEY_ROTATION_CHAIN_NOT_PUBLISHED` — не все DataItem подтверждены Arweave/Turbo publisher-ом; +- `KEY_ROTATION_BAD_SIGNATURE` — сохранённый `TECH_FORK` не подтверждается новым blockchain key; +- `KEY_ROTATION_TECH_FORK_*` — финальный `TECH_FORK` больше не соответствует rotation session; +- `KEY_ROTATION_FINISH_CHAIN_RACE` — состояние ротации было одновременно изменено другой операцией. + + +## `KeyRotationRotatePda` + +Фиксирует, что клиент уже локально подписал и отправил в Solana транзакцию полной ротации PDA. + +Сервер **не получает приватные ключи и не подписывает транзакцию**. Клиент передаёт только публичную Solana transaction signature. + +### Request + +```json +{ + "op": "KeyRotationRotatePda", + "requestId": "kr-rotate-pda-1", + "payload": { + "pdaRotationSignature": "" + } +} +``` + +Операция разрешена только после `CHAIN_READY`. Сервер атомарно сохраняет signature и переводит: + +`CHAIN_READY -> ROTATING_PDA`. + +После этого отмена ротации уже запрещена: отправленная Solana-транзакция может подтвердиться позже, даже если клиент потерял соединение. + +Подтверждением успешной ротации служит **не сам факт наличия signature**, а фактический current PDA, увиденный Solana sync. Sync требует одновременного совпадения: + +- `rootKey == newRootKey`; +- `blockchainKey == newBlockchainKey`; +- `clientKey == newClientKey`; +- `blockchainName == candidateBlockchainName`. + +Только после этого сервер атомарно переводит: + +`ROTATING_PDA -> PDA_ROTATED`. + +Если Solana sync успел увидеть новое PDA раньше вызова `KeyRotationRotatePda`, он умеет подтвердить ожидаемые ключи прямо из `CHAIN_READY`. Поэтому потеря клиентского запроса после уже подтверждённой Solana-транзакции не оставляет ротацию зависшей. Если API-вызов всё же приходит, handler идемпотентно возвращает текущее подтверждённое состояние. + +Повтор с той же signature идемпотентен. Другая signature для уже начатого `ROTATING_PDA` возвращает conflict. + +### Основные ошибки + +- `KEY_ROTATION_NOT_ACTIVE` — активной ротации нет; +- `KEY_ROTATION_NOT_CHAIN_READY` — candidate-chain ещё не подтверждена; +- `KEY_ROTATION_BAD_SOLANA_SIGNATURE` — signature отсутствует или не Base58; +- `KEY_ROTATION_PDA_SIGNATURE_CONFLICT` — для этой ротации уже сохранена другая signature; +- `KEY_ROTATION_ROTATE_PDA_FAILED` — внутренняя ошибка фиксации этапа. + + +## Автоматический rebuild после `PDA_ROTATED` + +После подтверждения нового current PDA сервер сам выполняет: + +`PDA_ROTATED -> REBUILDING_SERVER -> WALLET_MIGRATION`. + +Во время rebuild: + +- проверяется, что current PDA действительно указывает на `candidateBlockchainName/newBlockchainKey`; +- старая активная цепочка удаляется из рабочих PostgreSQL-таблиц; +- candidate-блоки повторно проходят обычный `AddBlock` validation/projection path; +- никакого rebind `to_bch_name` не выполняется: внешняя цель уже идентифицируется как `login + blockNumber + blockHash`; +- входящие `message_stats` не удаляются; для активных LIKE удаляемого пользователя точечно пересчитываются только затронутые like-счётчики; REPLY в Stage 2 отдельно не перерабатывается; +- после `COMPLETE` временные строки candidate-chain удаляются из PostgreSQL. + +Если rebuild прерывается, `REBUILDING_SERVER` остаётся активным, ошибка записывается в `lastError/retryCount`, а worker безопасно повторяет rebuild. + +## `KeyRotationContinue` + +Продолжает post-PDA этапы после фактической клиентской работы. Сервер не хранит приватные ключи и сам не переводит средства и не расшифровывает DM. + +### `WALLET_MIGRATION` + +Клиент сначала выполняет перенос SOL локально или пользователь явно пропускает перенос, затем вызывает: + +```json +{ + "op": "KeyRotationContinue", + "requestId": "kr-continue-wallet", + "payload": { + "walletMigrationStatus": "COMPLETE" + } +} +``` + +Допустимые значения: `COMPLETE`, `SKIPPED`. После фиксации сервер переводит ротацию в `MESSAGE_MIGRATION`. Автоматически переносится только SOL; другие активы пользователь переносит вручную. + +### `MESSAGE_MIGRATION` + +Момент перехода в `MESSAGE_MIGRATION` становится cutoff текущей DM-миграции (`updatedAtMs` состояния). Клиент выбирает старые локальные копии через `GetDirectMessages` с `reencryptedBeforeMs=cutoff`, перешифровывает их старым/новым client key и сохраняет через `ReencryptDirectMessage`, выставляя `reencryptedAtMs=cutoff`. + +После обхода клиент вызывает `KeyRotationContinue` с пустым payload. Сервер сам считает строки владельца с `message_type IN (1,2)`, `created_at_ms <= cutoff` и `reencrypted_at_ms < cutoff`. Если они ещё есть, возвращается `KEY_ROTATION_DM_PENDING`. Если нет — `message_migration_status=COMPLETE`, затем `FINALIZING -> COMPLETE`. + +Эта схема позволяет безопасно продолжить после перезапуска: уже обновлённые сообщения больше не попадают в выборку. Новые сообщения, сохранённые после начала `MESSAGE_MIGRATION`, в текущую миграцию не включаются. + +## `KeyRotationAbort` + +Прерывает ротацию только пока Solana-ротация PDA ещё не могла быть отправлена: + +- разрешено из `COPYING_CHAIN`; +- разрешено из `CHAIN_READY`; +- начиная с `ROTATING_PDA` отмена запрещена, процесс можно только довести вперёд. + +Request: + +```json +{ + "op": "KeyRotationAbort", + "requestId": "kr-abort-1", + "payload": {} +} +``` + +При `ABORTED` временные candidate-строки удаляются из PostgreSQL. Уже опубликованные Arweave DataItem остаются неизменяемым сиротским историческим следом и не становятся активной цепочкой, поскольку PDA не переключён. + +## Пользовательский flow key rotation (06.10.2026) + +`KeyRotationStart` после успешного создания ротации в той же транзакции удаляет все остальные активные сессии пользователя, оставляя текущую. После commit активные WebSocket-подключения этих сессий получают `SessionRevoked` и закрываются. + +Для пользователя подготовка `TECH_FORK` и последующая смена PDA выглядят как одна последовательность: если старый и новый наборы ключей ещё находятся в RAM, после `CHAIN_READY` клиент автоматически запускает Solana-ротацию без повторного ввода паролей. Серверные состояния остаются отдельными checkpoint'ами для безопасного восстановления. diff --git a/docs/API/20_Get_My_Blockchain_API.md b/docs/API/20_Get_My_Blockchain_API.md new file mode 100644 index 00000000..129e617e --- /dev/null +++ b/docs/API/20_Get_My_Blockchain_API.md @@ -0,0 +1,46 @@ +# GetMyBlockchain API + +`GetMyBlockchain` — авторизованное постраничное чтение **только текущей активной версии собственного блокчейна**. API используется постоянным экраном «Мой блокчейн» и мастером смены ключей для выбора последнего доверенного блока. + +Login и активный `blockchainName` сервер определяет из авторизованной сессии/current PDA; клиент не может запросить этим методом чужую цепочку. + +## Request + +```json +{ + "op": "GetMyBlockchain", + "requestId": "my-bch-1", + "payload": { + "beforeBlock": 500, + "limit": 50, + "includeBlockBytes": false + } +} +``` + +Поля: + +- `beforeBlock` — необязательный номер верхней границы страницы; если отсутствует, чтение начинается с current tip; +- `limit` — `1..100`, default `50`; +- `includeBlockBytes` — при `true` дополнительно вернуть полный ANS-104 DataItem в Base64. + +## Response + +Payload содержит: + +- `login`; +- `blockchainName`; +- `tipBlockNumber` / `tipBlockHash`; +- `nextBeforeBlock` для следующей страницы; +- `blocks[]` в порядке от новых к старым. + +Каждый элемент `blocks[]` содержит: + +- `blockNumber`; +- `blockHash` / `prevBlockHash`; +- `timestampMs`; +- `msgType` / `msgSubType` / `msgVersion`; +- для target-блоков: `toLogin + toForkNumber + toBlockNumber + toBlockHash` (для compact EDIT `toLogin/toForkNumber` отсутствуют); +- `blockBytesB64`, только если запрошен `includeBlockBytes=true`. + +После fork API показывает только новую активную ветку PostgreSQL. Исторические fork при необходимости восстанавливаются из Arweave/PDA history отдельным будущим viewer-механизмом. diff --git a/docs/API/21_Public_File_Storage_API.md b/docs/API/21_Public_File_Storage_API.md new file mode 100644 index 00000000..62897651 --- /dev/null +++ b/docs/API/21_Public_File_Storage_API.md @@ -0,0 +1,104 @@ +# HTTP API публичных файлов каналов + +## 1. Назначение + +Публичное вложение может храниться не в Arweave, а на текущем сервере доступа автора. +Файловый слой намеренно максимально простой: он хранит только байты, адресованные их SHA-256. + +Канонический URL: + +```text +/files/ +``` + +`sha256` — lowercase hex, ровно 64 символа. + +На диске сервер хранит один глобальный объект: + +```text +/ +``` + +Имя пользователя, исходное имя файла, расширение, MIME и ссылка на сообщение в файловом хранилище не нужны. Одинаковые байты, загруженные разными пользователями, дедуплицируются в один объект. + +## 2. Конфигурация Java-сервера + +```properties +public.files.enabled=true +public.files.storageDir=data/public-files +public.files.maxBytes=536870912 +``` + +Для production рекомендуется задать `public.files.storageDir` абсолютным путём, который одновременно доступен Java для записи и Caddy для чтения. + +Например: + +```text +/home/player/shine-public-files +``` + +## 3. PUT `/files/` + +Загружает immutable public file. PUT требует активную пользовательскую сессию. + +Заголовки: + +```text +Content-Type: application/octet-stream +X-Shine-Session-Id: +X-Shine-Time-Ms: +X-Shine-Content-Length: +X-Shine-Signature: +``` + +Подписываемая строка UTF-8: + +```text +PUBLIC_FILE_UPLOAD_V1:{sessionId}:{sha256}:{size}:{timeMs} +``` + +Сервер потоково принимает байты, заново считает SHA-256 и принимает объект только если: + +```text +SHA256(received bytes) == sha256 из URL +``` + +Если корректный объект уже существует и размер совпадает, PUT идемпотентно отвечает `alreadyExists=true`. + +## 4. GET и HEAD + +Java servlet умеет `GET` и `HEAD` как fallback. В production рекомендуется не пропускать чтение через Java: Caddy должен отдавать файл непосредственно с диска. + +Ответ immutable: + +```text +Cache-Control: public, max-age=31536000, immutable +ETag: "" +Content-Type: application/octet-stream +``` + +Файловое хранилище не определяет тип контента. Официальный клиент решает, как интерпретировать байты, на основании имени `nm` из `S:att`. Если пользователь указал неверное расширение или положил неподходящие байты, клиент просто не сможет отобразить такой media-файл. + +## 5. Связь с `S:att` + +```text +> +``` + +означает public file на текущем сервере доступа автора. + +```text +;ar=> +``` + +означает Arweave. + +Адрес сервера доступа в блок не записывается. При чтении клиент определяет текущий access server автора через его PDA и строит: + +```text +https:///files/ +``` + +## 6. Preview + +Отдельных preview-файлов сейчас нет. `preAr`, `preSha256`, `previewAr`, `previewSha256` не являются частью текущего протокола. diff --git a/docs/Blockchain/00_Blockchain_Formats_and_Block_Types.md b/docs/Blockchain/00_Blockchain_Formats_and_Block_Types.md index d4336ffa..9c8808b0 100644 --- a/docs/Blockchain/00_Blockchain_Formats_and_Block_Types.md +++ b/docs/Blockchain/00_Blockchain_Formats_and_Block_Types.md @@ -10,16 +10,16 @@ - `11_TEXT_Blocks.md` — текстовые блоки (`type=1`). - `12_REACTION_Blocks.md` — реакции (`type=2`). - `13_CONNECTION_Blocks.md` — связи/подписки (`type=3`). -- `14_USER_PARAM_Blocks.md` — пользовательские параметры (`type=4`). +- `14_USER_PROFILE_Blocks.md` — профиль пользователя (`type=4`). - `15_STATUS_ACTION_Blocks.md` — статусные действия (`type=5`). ## Быстрая карта типов -- `type=0` — TECH: HEADER, CREATE_CHANNEL. -- `type=1` — TEXT: POST/EDIT_POST/REPLY/EDIT_REPLY/RATING/REPOST/CHANNEL_META/ENTRYPOINT/EXERCISE/SERVICE/COURSE. +- `type=0` — TECH: HEADER, CREATE_CHANNEL, FORK. +- `type=1` — TEXT: POST/EDIT_POST/REPLY/EDIT_REPLY/RATING/REPOST/CHANNEL_META/CHANNEL_DELETE/ENTRYPOINT/EXERCISE/SERVICE/COURSE. - `type=2` — REACTION: LIKE/UNLIKE. - `type=3` — CONNECTION: FRIEND/CONTACT/FOLLOW/SPOUSE/PARENT/CHILD/SIBLING и обратные операции. -- `type=4` — USER_PARAM: key/value-параметры пользователя. +- `type=4` — USER_PROFILE: история полей профиля пользователя. - `type=5` — STATUS_ACTION: DONE_ONCE/LEARNED/SERVICE_PASSED/CONFIRMED/INTERESTED/STARTED/IN_STUDY/ABANDONED/COMPLETED. ## Примечание diff --git a/docs/Blockchain/01_Common_Block_Format.md b/docs/Blockchain/01_Common_Block_Format.md index 28a51ce2..e220a2c9 100644 --- a/docs/Blockchain/01_Common_Block_Format.md +++ b/docs/Blockchain/01_Common_Block_Format.md @@ -27,6 +27,7 @@ ANS-104 DataItem |---|---:|---| | `frameCode` | 2 | `0x0001` | | `prevHash32` | 32 | SHA-256 полного Frame v1 предыдущего SHiNE-блока; для блока 0 — нули | +| `back32Hash32` | 32 | SHA-256 Frame блока `N-32`; для `N<32` — 32 нулевых байта | | `blockSize` | 4 | точный размер Frame v1, включая header и body | | `blockNumber` | 4 | номер блока, начиная с 0 | | `timestamp` | 8 | Unix time seconds | @@ -35,11 +36,12 @@ ANS-104 DataItem | `version` | 2 | версия body | | `body` | N | данные конкретного типа | -`FRAME_HEADER_SIZE = 56` bytes. +`FRAME_HEADER_SIZE = 88` bytes. ```text blockHash32 = SHA256(FrameV1Bytes) next.prevHash32 = blockHash32 +blockN.back32Hash32 = (N < 32 ? ZERO_HASH_32 : HASH(block N-32)) ``` Подписи внутри Frame v1 нет. Единственная подпись пользователя — подпись окружающего ANS-104 DataItem. @@ -72,17 +74,29 @@ next.prevHash32 = blockHash32 Каждый блок: ```text -App = test5590 +App = test5591 ``` Это временное namespace-значение для разработки. Перед реальным запуском оно будет заменено отдельным изменением протокола/кода. +### Индексный тег фиксированного потока + +Для трёх фиксированных потоков используется короткий подписанный тег: + +```text +t=tech # TECH (HEADER / CREATE_CHANNEL / FORK) +t=conn # CONNECTION +t=prof # USER_PROFILE +``` + +Для TEXT, REACTION и STATUS_ACTION тег `t` отсутствует. Сервер проверяет точное соответствие значения `t` фактическому `msg_type`. + ### Канальный тег Если блок относится к конкретному каналу, он дополнительно содержит: ```text -c_test5590 = +c = ``` Slug входит в подпись DataItem и не может быть изменён сервером после подписи. @@ -106,11 +120,21 @@ Slug входит в подпись DataItem и не может быть изм Сервер обязан: 1. распарсить полный ANS-104 DataItem; -2. проверить `App=test5590`; -3. проверить `c_test5590`, если тип блока требует канал; -4. проверить ANS-104 Ed25519 подпись; -5. проверить, что `owner` равен текущему blockchain public key пользователя; -6. распарсить Frame v1 и body; -7. проверить `blockNumber == last + 1`; -8. проверить `prevHash32 == lastBlockHash`; -9. записать DataItem и новое состояние атомарно в PostgreSQL. +2. проверить `App=test5591`; +3. проверить `t`, если тип блока требует фиксированный индексный поток; +4. проверить `c`, если тип блока требует канал; +5. проверить ANS-104 Ed25519 подпись; +6. проверить, что `owner` равен текущему blockchain public key пользователя; +7. распарсить Frame v1 и body; +8. проверить `blockNumber == last + 1`; +9. проверить `prevHash32 == lastBlockHash`; +10. проверить `back32Hash32`: нули для `N<32`, иначе hash блока `N-32`; +11. проверить строгую непрерывность логической линии, если body line-based; +12. записать DataItem и новое состояние атомарно в PostgreSQL. + + +## Нормативное правило версий body + +После запуска layout существующей тройки `(type, subType, version)` неизменяем. Любое изменение порядка, размера или смысла подписываемых байтов требует новой `version`. В текущем чистом запуске используется только новый канонический layout; legacy-body не поддерживаются. + +Для внешних target-полей fork является исторической меткой, а не частью логической identity. Identity определяется `toLogin + toBlockGlobalNumber + toBlockHash32`. diff --git a/docs/Blockchain/02_Blockchain_Kinds_and_Lines.md b/docs/Blockchain/02_Blockchain_Kinds_and_Lines.md index 86e74275..f27df962 100644 --- a/docs/Blockchain/02_Blockchain_Kinds_and_Lines.md +++ b/docs/Blockchain/02_Blockchain_Kinds_and_Lines.md @@ -2,46 +2,87 @@ ## 1. Именованный блокчейн -Базовый идентификатор цепочки пользователя: +Базовый идентификатор физической цепочки пользователя: -- `blockchainName = -` -- пример: `alice-001` +- `blockchainName = -`; +- `NNN` — номер fork `001..999`; +- пример: `alice-001`. -Обычно это одна основная цепочка пользователя. +## 2. Логические линии внутри пользовательской цепочки -## 2. Логические линии внутри одной цепочки +Глобально все блоки пользователя идут одной последовательностью `blockNumber` и `prevHash32`; каждый Frame также содержит резервный `back32Hash32` на блок `N-32` (нули для `N<32`). Дополнительно некоторые типы образуют собственные проверяемые линии. Отдельного back32 внутри линий нет. -Физически цепочка одна, но внутри есть независимые логические последовательности (линии), которые ведутся через поля: +Актуальные линии: -- `lineCode` -- `prevLineNumber` -- `prevLineHash32` -- `thisLineNumber` +- `TECH` — системная история: `TECH_CREATE_CHANNEL`, `TECH_FORK`; root — `HEADER`; +- `TEXT` — отдельная линия каждого канала; root — `HEADER` для канала `0` или `TECH_CREATE_CHANNEL` для пользовательского канала; +- `CONNECTION` — единая история изменений связей пользователя; root — `HEADER`; +- `USER_PROFILE` — единая история изменений профиля пользователя; root — `HEADER`. -Линии используются для: -- TECH-событий; -- каналов с текстовыми постами; -- связей и подписок; -- пользовательских параметров. +`STATUS_ACTION` в line-модель сейчас не входит. -## 3. Правила line-полей (фактическая серверная валидация) +## 3. Два формата line-prefix -Line-поля: `lineCode`, `prevLineNumber`, `prevLineHash32`, `thisLineNumber`. +### 3.1. Линии с явным `lineCode` -- Line-поля разрешены только для `msg_type`: `0`, `1`, `3`, `4`. -- Если передано хотя бы одно line-поле, должны быть переданы все 4. -- `prevLineNumber/prevLineHash32` должны указывать на существующий блок этой же цепочки. -- Для первого шага после root (`prevLineNumber == lineCode`): - - `TEXT (msg_type=1)`: `thisLineNumber = 0`; - - `TECH/CONNECTION/USER_PARAM (0/3/4)`: `thisLineNumber = 1`. -- Для обычного шага: - - `TEXT`: `thisLineNumber` допускает `same` или `+1` от предыдущего блока линии; - - `TECH/CONNECTION/USER_PARAM`: строго `+1`. +`TECH` и `TEXT` хранят: -## 4. Root-идея для каналов и подписок +```text +[4] lineCode +[4] prevLineNumber +[32] prevLineHash32 +[4] thisLineNumber +``` -Для ссылок вида follow/friend/contact принято ссылаться на корневые блоки: -- `HEADER` для базовой сущности пользователя/канала `0`; -- `CREATE_CHANNEL` для пользовательских каналов. +- для TECH `lineCode=0`; +- для канала `lineCode = global blockNumber` его root-блока (`HEADER #0` либо `TECH_CREATE_CHANNEL`). -Так ссылки остаются стабильными, даже когда в канале появляются новые сообщения. +### 3.2. Фиксированные линии + +`CONNECTION` и `USER_PROFILE` имеют по одной линии на пользователя, поэтому `lineCode` в body не хранится. Их префикс: + +```text +[4] prevLineNumber +[32] prevLineHash32 +[4] thisLineNumber +``` + +Логический `lineCode` этих линий всегда `0`. + +## 4. Что означают номера + +`prevLineNumber` — **глобальный `blockNumber` предыдущего блока этой линии**. + +`thisLineNumber` — локальный порядковый номер внутри линии: + +- первый TEXT-блок канала: `0`, далее `1,2,3...`; +- первый TECH после HEADER: `1`, далее `2,3,4...`; +- первый CONNECTION: `1`, далее `2,3,4...`; +- первый USER_PROFILE: `1`, далее `2,3,4...`. + +То есть `prevLineNumber` и `thisLineNumber` — принципиально разные числа. + +## 5. Строгая серверная валидация + +Для каждого line-блока сервер определяет **текущий фактический хвост той же линии** и требует: + +1. `prevLineNumber` равен глобальному номеру текущего хвоста (либо root для первого блока); +2. `prevLineHash32` равен hash этого хвоста/root; +3. `thisLineNumber` равен предыдущему sequence `+1` (для первого TEXT — `0`, для остальных линий — `1`); +4. root существует и имеет правильный тип. + +Ссылка просто на любой существующий блок больше не считается допустимой. Это запрещает случайные или намеренные боковые ветки линии. + +Для канала в одну линию входят все line-based события этого канала, включая обычные посты, `EDIT_POST`, `REPOST`, `CHANNEL_META`, `CHANNEL_DELETE` и контентные типы канала. Поэтому редактирование не создаёт отдельную боковую ветку. + +## 6. Индексные ANS-104 теги + +Фиксированные системные потоки дополнительно индексируются подписанным тегом: + +```text +t=prof # USER_PROFILE +t=conn # CONNECTION +t=tech # TECH, включая HEADER / CREATE_CHANNEL / FORK +``` + +Тег является индексом для выборочной загрузки; криптографическая непрерывность обеспечивается line-полями внутри подписанного Frame/DataItem. diff --git a/docs/Blockchain/10_TECH_Blocks.md b/docs/Blockchain/10_TECH_Blocks.md index 0290844a..ef7ba550 100644 --- a/docs/Blockchain/10_TECH_Blocks.md +++ b/docs/Blockchain/10_TECH_Blocks.md @@ -1,18 +1,104 @@ # TECH блоки (`type=0`, `version=1`) -TECH-тип покрывает системные записи цепочки. +TECH-тип покрывает системные записи пользовательской цепочки. Все TECH DataItem имеют подписанный индексный тег: + +```text +t=tech +``` + +`HEADER` является root TECH-линии. Следующие line-based TECH-события (`TECH_CREATE_CHANNEL`, `TECH_FORK`) образуют одну последовательность с `lineCode=0`, ссылкой на предыдущий TECH-событийный блок и sequence `1..N`. ## Подтипы -1. `subType=0` — `HEADER_COMPAT` - - стартовый блок цепочки; - - payload: tag `SHiNE` + login владельца. +### `subType=0` — `HEADER_COMPAT` -2. `subType=1` — `TECH_CREATE_CHANNEL` - - создание нового канала; - - хранит line-поля + `channelName` + `channelDescription` + `channelType` + `channelTypeVersion`. +Стартовый блок цепочки (`block #0`). Payload содержит tag `SHiNE`, login владельца и `initialBlockchainKey32`. -## Назначение +`initialBlockchainKey32` — public blockchain-signing key, которым был создан fork №1; это историческая точка происхождения. При последующих fork значение не меняется. -- инициализация блокчейна; -- управление набором каналов пользователя. +HEADER сам не хранит line-prefix, но является root TECH-линии. + +### `subType=1` — `TECH_CREATE_CHANNEL` + +Создание нового канала. Блок одновременно: + +- является очередным шагом TECH-линии; +- является root нового канала; +- имеет `t=tech`; +- имеет `c=`. + +Начало body: + +```text +[4] lineCode = 0 +[4] prevTechBlockNumber +[32] prevTechBlockHash32 +[4] techSequence +``` + +Далее идут `channelName`, `channelDescription`, `channelType`, `channelTypeVersion` согласно формату CREATE_CHANNEL. + +### `subType=2` — `TECH_FORK` + +`TECH_FORK` фиксирует создание нового fork и является обычным следующим шагом TECH-линии. + +#### `TECH_FORK` body (`version=1`) + +Big-endian: + +```text +[4] lineCode = 0 +[4] prevTechBlockNumber +[32] prevTechBlockHash32 +[4] techSequence + +[32] parentBlockchainKey +[4] forkPointBlockNumber +[32] forkPointBlockHash32 +[8] forkPointTimestampMs +[4] parentTipBlockNumber +[32] parentTipBlockHash32 +[8] parentTipTimestampMs +[4] discardedBlocksCount +[1] reasonCode +[2] commentUtf8Length +[N] comment UTF-8 +``` + +- `prevTechBlockNumber` — глобальный blockNumber предыдущего TECH-события; если до fork не было CREATE_CHANNEL/FORK, это `HEADER #0`; +- `prevTechBlockHash32` — hash этого блока; +- `techSequence` — предыдущий TECH sequence + 1; первый TECH-событийный блок после HEADER имеет `1`. + +Остальная fork-часть: + +- `parentBlockchainKey[32]` — public key предыдущего fork; +- `forkPointBlockNumber[4]` — последний блок старой цепочки, сохранённый в новом fork; +- `forkPointBlockHash32[32]`; +- `forkPointTimestampMs[8]`; +- `parentTipBlockNumber[4]` — tip старой цепочки на момент начала ротации; +- `parentTipBlockHash32[32]`; +- `parentTipTimestampMs[8]`; +- `discardedBlocksCount[4] = parentTipBlockNumber - forkPointBlockNumber`; +- `reasonCode[1]`; +- `commentUtf8Length[2]`; +- `comment[N]` — максимум 1024 UTF-8 байт. + +`reasonCode`: + +- `1` — `ROUTINE_ROTATION`; +- `2` — `POSSIBLE_COMPROMISE`; +- `3` — `CONFIRMED_COMPROMISE_ROLLBACK`; +- `4` — `RECOVERY`. + +Текущая схема ротации перепубликует выбранный префикс `0..forkPointBlockNumber` новым blockchain key и затем добавляет `TECH_FORK`. Перепубликованные Frame сохраняются байт-в-байт; внешняя ANS-104 owner/signature меняется. Новый blockchain key в body не дублируется: он определяется owner/signature нового DataItem. + +## Серверная проверка TECH-линии + +Для `TECH_CREATE_CHANNEL` и `TECH_FORK` сервер требует: + +1. `lineCode=0`; +2. первый TECH-событийный блок ссылается на HEADER и имеет sequence `1`; +3. каждый следующий ссылается на фактический текущий хвост TECH-линии; +4. номер предыдущего блока, его hash и sequence должны совпадать точно. + +Таким образом CREATE_CHANNEL и FORK образуют единый проверяемый технический позвоночник пользователя. diff --git a/docs/Blockchain/11_TEXT_Blocks.md b/docs/Blockchain/11_TEXT_Blocks.md index 226934be..f37f3b7c 100644 --- a/docs/Blockchain/11_TEXT_Blocks.md +++ b/docs/Blockchain/11_TEXT_Blocks.md @@ -10,20 +10,20 @@ TEXT-тип хранит сообщения, материалы и редакт 2. `subType=11` — `TEXT_EDIT_POST` - редактирование поста; - - line-поля + target на оригинальный POST + новый текст. + - line-поля + compact target (`toBlockGlobalNumber`, `toBlockHash32`) на оригинальный POST + новый текст. 3. `subType=20` — `TEXT_REPLY` - ответ на сообщение; - - target (`toBlockchainName`, `toBlockGlobalNumber`, `toBlockHash32`) + текст. + - target (`toLogin`, `toForkNumber`, `toBlockGlobalNumber`, `toBlockHash32`) + текст. 4. `subType=21` — `TEXT_EDIT_REPLY` - редактирование ответа; - - target на исходный REPLY + новый текст. + - compact target (`toBlockGlobalNumber`, `toBlockHash32`) на исходный REPLY + новый текст. - допускается пустой `text` для логического удаления сообщения (без физического удаления блока). 5. `subType=30` — `TEXT_RATING` - target-based отзыв на конкретный блок; - - содержит target (`toBlockchainName`, `toBlockGlobalNumber`, `toBlockHash32`) + текст отзыва; + - содержит target (`toLogin`, `toForkNumber`, `toBlockGlobalNumber`, `toBlockHash32`) + текст отзыва; - не является сообщением линии канала. 6. `subType=50` — `TEXT_REPOST` @@ -38,24 +38,54 @@ TEXT-тип хранит сообщения, материалы и редакт - не отображается как обычное сообщение ленты; - применяется сервером к текущему состоянию канала. -8. `subType=100` — `TEXT_ENTRYPOINT` +8. `subType=92` — `TEXT_CHANNEL_DELETE` + - скрытый технический soft-delete канала; + - содержит line-поля и обязательный пустой `text`; + - становится хвостом той же линии канала; + - новый самостоятельный channel-пост автоматически делает канал активным снова; `CHANNEL_META` и `EDIT_POST` не оживляют канал. + +9. `subType=100` — `TEXT_ENTRYPOINT` - входная страница канала; - line-based сообщение с тем же body, что у `TEXT_POST`; - не редактируется через `TEXT_EDIT_POST`: новая версия создаётся новым `TEXT_ENTRYPOINT`. -9. `subType=110` — `TEXT_EXERCISE` +10. `subType=110` — `TEXT_EXERCISE` - line-based материал упражнения; - использует тот же body, что у `TEXT_POST`. -10. `subType=120` — `TEXT_SERVICE` +11. `subType=120` — `TEXT_SERVICE` - line-based материал услуги / процедуры; - использует тот же body, что у `TEXT_POST`. -11. `subType=130` — `TEXT_COURSE` +12. `subType=130` — `TEXT_COURSE` - line-based материал курса; - использует тот же body, что у `TEXT_POST`. -Подробная спецификация: [16_TEXT_Channel_Meta.md](./16_TEXT_Channel_Meta.md). +Подробные спецификации: [16_TEXT_Channel_Meta.md](./16_TEXT_Channel_Meta.md) и [17_TEXT_Channel_Delete.md](./17_TEXT_Channel_Delete.md). + + +## Канонический target-формат TEXT + +Внешние цели (`TEXT_REPLY`, `TEXT_RATING`, `TEXT_REPOST`) используют: + +```text +[1] toLoginLen (uint8) +[N] toLogin UTF-8 +[2] toForkNumber (uint16, BigEndian) +[4] toBlockGlobalNumber +[32] toBlockHash32 +``` + +`toForkNumber`: строго `1..999` — fork, который видел автор действия. Поле информационное и **не входит в логическую идентичность цели**. Цель определяется только `toLogin + toBlockGlobalNumber + toBlockHash32`; несовпадение текущего fork само по себе не инвалидирует ссылку. + +Собственные edit (`TEXT_EDIT_POST`, `TEXT_EDIT_REPLY`) используют компактный target: + +```text +[4] toBlockGlobalNumber +[32] toBlockHash32 +``` + +Login/fork для edit не подписываются: edit может ссылаться только на собственный блок текущей цепочки. ## Правило для edit @@ -71,7 +101,7 @@ TEXT-тип хранит сообщения, материалы и редакт - Для `TEXT_EDIT_POST` и `TEXT_EDIT_REPLY` допустим `textLen=0`. - Такой edit трактуется как логическое удаление содержимого сообщения. -- Для удаления используется именно edit-блок; отдельного `DELETE`-подтипа нет. +- Для удаления отдельного сообщения используется именно edit-блок; отдельного `DELETE`-подтипа сообщения нет. `TEXT_CHANNEL_DELETE=92` относится только к soft-delete всего канала. ## Вложения в текстовых сообщениях (`S:att v=1`) @@ -81,16 +111,16 @@ TEXT-тип хранит сообщения, материалы и редакт Бинарный формат `TextBody` не меняется: вложения являются частью UTF-8 текста. -Один блок вложения: +Arweave-вложение: ```text ``` -Для файлов с отдельным превью клиент может использовать расширенный вариант: +Вложение на сервере доступа автора: ```text - + ``` Несколько вложений идут подряд в самом начале текста, по одному блоку на строку. После последнего блока идёт обычный пользовательский текст. @@ -101,8 +131,18 @@ TEXT-тип хранит сообщения, материалы и редакт - `nm` - имя файла, закодированное через `encodeURIComponent` - `sz` - размер файла в байтах - `sha256` - SHA-256 исходного файла в hex -- `ar` - короткий Arweave Transaction ID, без полного URL -- при наличии превью дополнительно могут присутствовать `preAr` и `preSha256` + +Опциональное поле: + +- `ar` - короткий Arweave Transaction ID, без полного URL. + +Правило источника файла: + +- `ar` присутствует -> файл хранится в Arweave; +- `ar` отсутствует -> файл хранится как public file на текущем сервере доступа автора и читается по `/files/`; +- адрес сервера доступа в attach-блок не записывается. + +Отдельные preview-файлы сейчас **не поддерживаются и не являются частью текущего протокола**. Поля `preAr`, `preSha256`, `previewAr`, `previewSha256` новые клиенты создавать не должны. Изображения и видео отображаются из исходного файла. Правила клиента: @@ -111,4 +151,4 @@ TEXT-тип хранит сообщения, материалы и редакт - старые клиенты без поддержки вложений могут показывать технические строки как обычный текст; - пустой пользовательский текст допустим, если перед ним есть хотя бы один валидный attach-блок. -Файлы хранятся вне блокчейна, в Arweave. В блокчейне остаются только `txId`, имя, размер, SHA-256 и, при наличии отдельного preview-файла, `preAr/preSha256`. +Сам файл всегда хранится вне блокчейна. В блокчейне остаются имя, размер, SHA-256 и, только для Arweave-вложения, `ar`. diff --git a/docs/Blockchain/12_REACTION_Blocks.md b/docs/Blockchain/12_REACTION_Blocks.md index 58f8ac25..b94a489d 100644 --- a/docs/Blockchain/12_REACTION_Blocks.md +++ b/docs/Blockchain/12_REACTION_Blocks.md @@ -4,11 +4,24 @@ 1. `subType=1` — `REACTION_LIKE` - лайк на целевой блок; - - хранит target: `toBlockchainName`, `toBlockGlobalNumber`, `toBlockHash32`. + - хранит target: `toLogin`, `toForkNumber`, `toBlockGlobalNumber`, `toBlockHash32`. 2. `subType=2` — `REACTION_UNLIKE` - снятие лайка с целевого блока; - - хранит target: `toBlockchainName`, `toBlockGlobalNumber`, `toBlockHash32`. + - хранит target: `toLogin`, `toForkNumber`, `toBlockGlobalNumber`, `toBlockHash32`. ## Назначение - реакция на текстовые сообщения (и потенциально другие target-блоки, если это разрешено бизнес-логикой). + + +## Формат target + +```text +[1] toLoginLen (uint8) +[N] toLogin UTF-8 +[2] toForkNumber (uint16, BigEndian) +[4] toBlockGlobalNumber +[32] toBlockHash32 +``` + +`toForkNumber` — только историческая метка и всегда находится в диапазоне `1..999`. Логическая идентичность реакции: `toLogin + toBlockGlobalNumber + toBlockHash32`. При fork номер fork может измениться; если number+hash сохранены в новой ветке, LIKE/UNLIKE продолжает указывать на тот же логический блок. diff --git a/docs/Blockchain/13_CONNECTION_Blocks.md b/docs/Blockchain/13_CONNECTION_Blocks.md index b2991b57..0dfceedc 100644 --- a/docs/Blockchain/13_CONNECTION_Blocks.md +++ b/docs/Blockchain/13_CONNECTION_Blocks.md @@ -1,29 +1,68 @@ # CONNECTION блоки (`type=3`, `version=1`) -CONNECTION-тип описывает социальные связи и подписки. +CONNECTION описывает историю социальных связей и подписок пользователя. ## Подтипы -• `10/11` — `close_friend / unclose_friend` (близкий друг) -• `20/21` — `contact / uncontact` (контакт) -• `30/31` — `follow / unfollow` (подписан) -• `40/41` — `spouse / unspouse` (супруг/супруга) -• `50/51` — `parent / unparent` (родитель) -• `52/53` — `child / unchild` (ребёнок) -• `54/55` — `sibling / unsibling` (брат/сестра) -• `60/61` — `known_person / unknown_person` (знаю этого человека) -• `70/71` — `shine_confirmed / shine_unconfirmed` (точно уверен, что сияющий) -• `74/75` — `shine_seen / shine_unseen` (мало знаком, но видел сияющим) +• `10/11` — `close_friend / unclose_friend` (близкий друг) +• `14/15` — `friend / unfriend` (друг) +• `20/21` — `contact / uncontact` (контакт) +• `30/31` — `follow / unfollow` (подписка) +• `40/41` — `spouse / unspouse` +• `50/51` — `parent / unparent` +• `52/53` — `child / unchild` +• `54/55` — `sibling / unsibling` +• `70/71` — `shine_confirmed / shine_unconfirmed` +• `74/75` — `shine_seen / shine_unseen` +• `80/81` — `official_account / unofficial_account` -## Общий формат payload +`60/61` — legacy/reserved и новым UI не создаются. -- line-поля (`lineCode`, `prevLineNumber`, `prevLineHash32`, `thisLineNumber`) -- target (`toBlockchainName`, `toBlockGlobalNumber`, `toBlockHash32`) +## Линия связей -## Правила target +У пользователя существует ровно одна линия `CONNECTION`. Отдельный `lineCode` в body не хранится: логический код линии всегда `0`. -- FRIEND/CONTACT обычно указывают на `HEADER` цели (`block 0`). -- FOLLOW указывает на root канала: - - `HEADER` для канала `0`; - - `CREATE_CHANNEL` для пользовательского канала. -- Для остальных типов связи (`SPOUSE/PARENT/CHILD/SIBLING`) используется тот же target-формат. +Первый CONNECTION ссылается на `HEADER #0` и имеет `connectionSequence=1`. Каждый следующий обязан ссылаться на фактический текущий хвост CONNECTION-линии и увеличивать sequence ровно на `1`. + +## Body (`version=1`) + +Big-endian: + +```text +[4] prevConnectionBlockNumber +[32] prevConnectionBlockHash32 +[4] connectionSequence + +[1] toLoginLen +[N] toLogin UTF-8 +[2] toForkNumber +[4] toBlockGlobalNumber +[32] toBlockHash32 +``` + +- `prevConnectionBlockNumber` — глобальный `blockNumber` предыдущего CONNECTION-блока. +- `prevConnectionBlockHash32` — SHA-256 Frame предыдущего CONNECTION-блока. +- `connectionSequence` — порядковый номер изменения связей `1..N`. + +Сервер проверяет номер, hash и sequence относительно текущего хвоста CONNECTION-линии. Это позволяет выгрузить только связи пользователя и проверить, что внутри выбранной истории нет пропущенного шага. + +## Target + +`toForkNumber` хранит fork, который видел автор связи (`1..999`), но не входит в логическую identity цели. `0` зарезервирован как unknown/legacy; `1000+` недопустим. + +Для связи на пользователя обычно используется его HEADER: + +```text +toBlockGlobalNumber=0 +toBlockHash32=SHA-256(Frame HEADER) +``` + +Для FOLLOW на канал target указывает на root канала: HEADER для канала `0` либо `TECH_CREATE_CHANNEL` для пользовательского канала. + +## ANS-104 тег + +Каждый CONNECTION обязан иметь подписанный тег: + +```text +t=conn +``` diff --git a/docs/Blockchain/14_USER_PARAM_Blocks.md b/docs/Blockchain/14_USER_PARAM_Blocks.md deleted file mode 100644 index b4928a7b..00000000 --- a/docs/Blockchain/14_USER_PARAM_Blocks.md +++ /dev/null @@ -1,14 +0,0 @@ -# USER_PARAM блоки (`type=4`, `version=1`) - -## Подтипы - -1. `subType=1` — `USER_PARAM_TEXT_TEXT` - - хранит line-поля + `paramKey` + `paramValue`. - -## Назначение - -- сохранение пользовательского состояния (настройки клиента, синк-метки, курсоры чтения и т.д.). - -## Практика - -Для сложных структур удобно хранить JSON-строку в `paramValue` с версией схемы. diff --git a/docs/Blockchain/14_USER_PROFILE_Blocks.md b/docs/Blockchain/14_USER_PROFILE_Blocks.md new file mode 100644 index 00000000..f87ecd12 --- /dev/null +++ b/docs/Blockchain/14_USER_PROFILE_Blocks.md @@ -0,0 +1,45 @@ +# USER_PROFILE блоки (`type=4`, `version=1`) + +`USER_PROFILE` хранит только данные, которыми пользователь описывает собственный профиль. + +> В текущем Java/JS коде историческое внутреннее имя класса/метода может оставаться `UserParamBody` / `addBlockUserParam`. На уровне протокола и документации тип называется `USER_PROFILE`. + +## Подтип + +`subType=1` — текстовое поле профиля: `paramKey + paramValue`. + +Примеры полей: имя, фамилия, `about`, аватар, web, телефон, роль аккаунта и другие свойства профиля, определённые приложением. + +## Линия профиля + +У пользователя существует ровно одна линия `USER_PROFILE`. Отдельный `lineCode` для неё не нужен и в body не хранится: логический код линии всегда `0`. + +Первый `USER_PROFILE` ссылается на `HEADER #0` и имеет `profileSequence=1`. Каждый следующий блок обязан ссылаться на фактический текущий хвост профильной линии и увеличивать sequence ровно на `1`. + +## Body (`version=1`) + +Big-endian: + +```text +[4] prevProfileBlockNumber +[32] prevProfileBlockHash32 +[4] profileSequence +[2] paramKeyLen +[N] paramKey UTF-8 +[2] paramValueLen +[M] paramValue UTF-8 +``` + +- `prevProfileBlockNumber` — **глобальный `blockNumber`** предыдущего блока профильной линии, а не локальный sequence. +- `prevProfileBlockHash32` — SHA-256 Frame предыдущего блока профильной линии. +- `profileSequence` — порядковый номер изменения профиля `1..N`. + +Сервер проверяет одновременно номер предыдущего блока, его hash и непрерывность sequence. Поэтому выборка всех блоков `USER_PROFILE` позволяет обнаружить пропуск или боковую ветку. + +## ANS-104 тег + +Каждый `USER_PROFILE` обязан иметь подписанный тег: + +```text +t=prof +``` diff --git a/docs/Blockchain/15_STATUS_ACTION_Blocks.md b/docs/Blockchain/15_STATUS_ACTION_Blocks.md index 1a330569..9a364298 100644 --- a/docs/Blockchain/15_STATUS_ACTION_Blocks.md +++ b/docs/Blockchain/15_STATUS_ACTION_Blocks.md @@ -36,8 +36,9 @@ Все `STATUS_ACTION` используют один и тот же бинарный body-формат: ```text -[1] toBlockchainNameLen (uint8) -[N] toBlockchainName UTF-8 +[1] toLoginLen (uint8) +[N] toLogin UTF-8 +[2] toForkNumber uint16 (BigEndian) [4] toBlockGlobalNumber [32] toBlockHash32 [2] textLenBytes (uint16) @@ -46,7 +47,8 @@ Где: -- `toBlockchainName` — блокчейн, в котором находится целевой материал; +- `toLogin` — login владельца целевого блока; +- `toForkNumber` — историческая метка fork (`1..999`), не часть identity; - `toBlockGlobalNumber` — номер целевого блока; - `toBlockHash32` — хэш целевого блока; - `text` — опциональное пояснение пользователя к статусу. diff --git a/docs/Blockchain/15_TEXT_Attachments.md b/docs/Blockchain/15_TEXT_Attachments.md index 1896401e..ddb40871 100644 --- a/docs/Blockchain/15_TEXT_Attachments.md +++ b/docs/Blockchain/15_TEXT_Attachments.md @@ -15,112 +15,109 @@ ## Общий вид -Канонический attach-блок: +Arweave-вложение: ```text ``` -Блок с превью: +Public file на сервере доступа автора: ```text - + ``` Несколько вложений идут подряд в самом начале текста: ```text - + Текст сообщения ``` После последнего attach-блока идёт обычный пользовательский текст. Пользовательский текст может быть пустым, если есть хотя бы одно валидное вложение. -Клиент SHiNE ограничивает одно сообщение максимум 10 вложениями и сохраняет порядок attach-блоков в том порядке, в котором пользователь прикрепил файлы. +Клиент SHiNE ограничивает одно сообщение максимум 10 вложениями и сохраняет порядок attach-блоков. ## Поля -Обязательные поля канонического формата: +Обязательные поля: - `v=1` - версия формата attach-блока; - `nm` - имя файла, закодированное через `encodeURIComponent`; - `sz` - размер файла в байтах; -- `sha256` - SHA-256 исходного файла в hex, 64 символа; +- `sha256` - SHA-256 исходного файла в hex, 64 символа. + +Опциональное поле: + - `ar` - короткий Arweave Transaction ID, 43 символа, без gateway URL. -Дополнительные поля для превью: +Источник определяется только наличием `ar`: -- `preAr` - короткий Arweave Transaction ID файла-превью; -- `preSha256` - SHA-256 файла-превью в hex. +- `ar` присутствует -> Arweave; +- `ar` отсутствует -> public file текущего сервера доступа автора. + +Адрес сервера доступа, URL файла и login автора в attach-блок не записываются: автор уже известен из подписанного блока, а актуальный сервер доступа определяется отдельно. + +## Preview + +Отдельные preview-файлы в текущем протоколе **не поддерживаются и пока не нужны**. + +Клиент не должен создавать или использовать поля `preAr`, `preSha256`, `previewAr`, `previewSha256`. Для изображения или видео используется исходный файл вложения. + +Если такие поля встречаются в экспериментальных старых данных, текущая реализация может их игнорировать; они не являются частью канонического `S:att v=1`. ## Хранение файла -Файл хранится вне блокчейна в Arweave. В блокчейне хранится только метаинформация, достаточная для отображения и проверки: +Сам файл всегда находится вне блокчейна. -- имя файла; -- размер; -- SHA-256; -- Arweave `txId`. +### Arweave -Опционально для видео или больших изображений может храниться отдельный второй файл-превью. В таком случае основной attach-блок остаётся одним, но дополнительно указывает `preAr/preSha256`. +Если присутствует `ar`, файл читается через настроенный Arweave gateway по указанному `txId`. + +### Сервер доступа + +Если `ar` отсутствует, клиент: + +1. определяет текущий сервер доступа автора сообщения; +2. запрашивает файл по стандартному пути `/files/`; +3. при необходимости проверяет полученные байты по `sha256` из блока. + +Физическое хранилище сервера является content-addressed: один и тот же SHA-256 должен соответствовать одному набору байтов. Это позволяет дедуплицировать одинаковые файлы разных пользователей. + +URL или домен конкретного сервера в блокчейн не записывается. Поэтому смена сервера доступа не требует изменения старых сообщений. ## Создание вложения в UI -UI поддерживает три сценария: +UI предлагает два способа хранения: `Сервер доступа` и `Arweave`. По умолчанию выбран сервер доступа. Отдельные preview-файлы не создаются. -- загрузить новый файл в Arweave выбранным Arweave-кошельком; -- ввести существующий `txId`, скачать файл через Arweave gateway и локально посчитать `size/sha256`; -- выбрать файл из журнала файлов, загруженных в текущей браузерной сессии. +После успешной загрузки на сервер доступа формируется тот же `S:att v=1`, но без поля `ar`. Для Arweave используется существующий механизм Arweave/Turbo и добавляется `ar`. -Для видеофайлов UI может по желанию пользователя автоматически создать превью из первого кадра. Технически клиент загружает два файла: - -- основной видеофайл; -- отдельное изображение-превью. - -После успешной загрузки в журнале хранится один элемент основного файла, но с полями `preAr/preSha256`. В UI такой элемент помечается как файл `С превью`. - -При ручном добавлении существующего `txId` для видео UI также позволяет вручную указать `txId` файла-превью. - -Журнал хранится только в `sessionStorage` текущего браузера и не является частью блокчейна. -В настройках клиента есть отдельный экран `Загрузка файлов`: пользователь может заранее загрузить файл в Arweave без создания сообщения, увидеть компактную плитку с именем, размером, временем загрузки, `txId` и статусом доступности через gateway, а затем выбрать этот файл из истории при создании сообщения. -Если файл загружен заранее, но ещё не был отправлен ни в одном сообщении SHiNE, клиент показывает локальный флаг `Не добавлен в SHiNE`. Флаг снимается после успешной отправки сообщения с этим вложением. -Если история очищена, уже созданные сообщения не меняются: в блокчейне остаются attach-блоки с `txId`. +Журнал загрузок Arweave хранится только в `sessionStorage` текущего браузера и не является частью блокчейна. ## Отображение -Новый клиент при чтении сообщения: +Клиент при чтении сообщения: 1. читает валидные attach-блоки только из начала текста; 2. скрывает технические attach-строки; -3. отображает вложения над пользовательским текстом; -4. показывает вложения горизонтальной каруселью: одно вложение на экране, переключение свайпом или стрелками, счётчик вида `1 из 3`; -5. определяет тип вложения по расширению имени файла: - - изображение показывает как ограниченное по размеру превью; - - видео показывает как превью с кнопкой воспроизведения и открывает большой HTML5-плеер по нажатию; - - обычный файл показывает как карточку с именем, расширением, размером и скачиванием; -6. если у видео есть `preAr/preSha256`, использует отдельный preview-файл как `poster` и как большую превью-плитку в журнале загрузок; -7. при перелистывании останавливает воспроизводящееся видео; -8. если attach-блок битый, игнорирует только этот блок и продолжает отображать сообщение. - -Если файл по ссылке Arweave gateway недоступен, клиент показывает диагностический блок: - -- если сообщение создано менее 20 минут назад: файл, скорее всего, ещё не распространился в Arweave, нужно повторить через несколько минут; -- если сообщение старше 20 минут: файл считается недоступным. - -Старые клиенты без поддержки формата могут показывать attach-блоки как обычный текст. +3. определяет источник по наличию `ar`; +4. получает Arweave-файл по `txId` либо server-файл по `/files/` текущего сервера доступа автора; +5. определяет тип вложения по расширению `nm`; +6. изображение отображает из исходного файла; +7. видео отображает из исходного файла и открывает HTML5-плеер; +8. обычный файл показывает как карточку с именем, размером и скачиванием; +9. при перелистывании останавливает воспроизводящееся видео; +10. битый attach-блок игнорирует, не ломая остальное сообщение. ## Редактирование -При редактировании сообщения UI сохраняет существующие attach-блоки и меняет только пользовательский текст. Удаление сообщения по-прежнему выполняется через edit-блок с пустым текстом, как описано в `11_TEXT_Blocks.md`. +При редактировании сообщения UI сохраняет существующие attach-блоки и меняет только пользовательский текст. Удаление сообщения выполняется через edit-блок с пустым текстом, как описано в `11_TEXT_Blocks.md`. ## Совместимость и ограничения -- `ar` допускает только короткий Arweave `txId`, полный URL не используется; -- MIME type не записывается, поэтому UI определяет image/video/file по расширению имени файла; -- старые блоки ``, промежуточные `` и новые `` читаются одинаково; -- старые поля `name/size/previewAr/previewSha256` и новые `nm/sz/preAr/preSha256` читаются одинаково; -- старые блоки `v=2` продолжают читаться как legacy-форма вложения с превью; -- `preAr/preSha256` используются только если присутствуют оба поля и оба валидны; -- MIME type, width, height, duration и thumbnail не записываются в блокчейн отдельными полями; -- проверка существующего `txId` скачивает файл локально через gateway, поэтому UI ограничивает максимальный размер такой проверки. +- полный URL в поле `ar` не используется; +- MIME type не записывается, тип UI определяется по расширению `nm`; +- старые текстовые префиксы `` и `` могут продолжать читаться как совместимые формы; +- отдельные preview-поля не входят в текущий протокол; +- MIME type, width, height, duration и thumbnail не записываются в блокчейн отдельными полями. diff --git a/docs/Blockchain/17_ANS104_Arweave_Transport.md b/docs/Blockchain/17_ANS104_Arweave_Transport.md index 259b1ea1..089ce2c6 100644 --- a/docs/Blockchain/17_ANS104_Arweave_Transport.md +++ b/docs/Blockchain/17_ANS104_Arweave_Transport.md @@ -1,5 +1,7 @@ # ANS-104 / Arweave transport для пользовательских блоков SHiNE +> **Текущий transport namespace:** `test5591`. Он намеренно хранится отдельно в трёх рабочих местах: сервер (`ShineProtocolTags.java`), UI (`js/services/protocol-tags.js`) и актуальный Viewer (`static-sites/arweave-viewer/index.html`). При смене тестовой эпохи эти три значения меняются синхронно. Имя канального индексного тега постоянно и не зависит от namespace: `c`. + ## Цель Каждый пользовательский блок SHiNE уже на клиенте является самостоятельным подписанным ANS-104 DataItem. Сервер проверяет и хранит **точно эти signed bytes** и может публиковать их одним из двух транспортов: через Turbo по одному DataItem либо через прямую Arweave L1-транзакцию в составе стандартного большого ANS-104 bundle. @@ -11,16 +13,26 @@ Для тестового контура обязательно: ```text -App=test5590 +App=test5591 +``` + +Для фиксированных потоков: + +```text +t=tech # TECH: HEADER / CREATE_CHANNEL / FORK +t=conn # CONNECTION +t=prof # USER_PROFILE ``` Для блоков конкретного канала дополнительно: ```text -c_test5590= +c= ``` -Теги входят в ANS-104 подпись пользователя. Старый тестовый тег `c` новым кодом не создаётся и не принимается как channel tag. +`TECH_CREATE_CHANNEL` несёт оба индекса: `t=tech` и `c=`. `STATUS_ACTION` не получает `t`-тег. + +Теги входят в ANS-104 подпись пользователя. Сервер проверяет соответствие `t` фактическому `msg_type` и отклоняет лишний/неверный `t`. Старый тестовый тег `c` новым кодом не создаётся и не принимается как channel tag. ## Publisher modes @@ -82,7 +94,7 @@ Bundle-Version=2.0.0 Content-Type=application/octet-stream ``` -Специальный `App=test5590-batch` больше не используется. Важны вложенные user DataItems, у которых уже есть `App=test5590`. +Специальный `App=test5591-batch` больше не используется. Важны вложенные user DataItems, у которых уже есть `App=test5591`. ### `none` @@ -102,7 +114,7 @@ Content-Type=application/octet-stream Importer всегда выполняет один discovery-запрос: ```text -App=test5590 +App=test5591 ``` Он **не ищет root bundles** и не зависит от `publish.mode`. @@ -120,7 +132,7 @@ App=test5590 Поэтому importer: -1. получает `data_item_id` через GraphQL `App=test5590`; +1. получает `data_item_id` через GraphQL `App=test5591`; 2. запрашивает `GET /ar-io/offsets/{data_item_id}`; 3. получает `rootTxId`, `rootOffset`, `size`; 4. делает range-read `GET /raw/{rootTxId}` ровно по этому диапазону; diff --git a/docs/Blockchain/17_TEXT_Channel_Delete.md b/docs/Blockchain/17_TEXT_Channel_Delete.md new file mode 100644 index 00000000..a67c5e31 --- /dev/null +++ b/docs/Blockchain/17_TEXT_Channel_Delete.md @@ -0,0 +1,70 @@ +# TEXT_CHANNEL_DELETE: soft-delete канала + +`TEXT_CHANNEL_DELETE` — технический `TEXT`-блок линии канала, который помечает канал удалённым без удаления его истории или адреса. + +## Код подтипа + +- `type = 1` (`TEXT`) +- `subType = 92` (`TEXT_CHANNEL_DELETE`) +- `version = 1` + +## Body + +Используется обычный line-based `TextLineBody` канала: + +```text +[4] lineCode = global block number корневого TECH_CREATE_CHANNEL +[4] prevLineNumber +[32] prevLineHash32 +[4] thisLineNumber +[4] textLen = 0 +``` + +Поле `text` обязано быть пустым. Блок участвует в той же строгой линии канала, что `TEXT_POST`, `TEXT_EDIT_POST`, `TEXT_REPOST`, `TEXT_CHANNEL_META` и контентные типы. Поэтому после удаления именно `TEXT_CHANNEL_DELETE` является текущим хвостом линии. + +ANS-104 DataItem обязан содержать обычный channel index `c=`. Запись выполняется только через `AddBlock`. + +## Семантика состояния + +После валидного `TEXT_CHANNEL_DELETE` канал имеет состояние `deleted`. Физически ничего не удаляется: + +- root канала и slug сохраняются; +- все старые блоки и сообщения остаются читаемыми; +- старые/прямые ссылки продолжают открывать канал; +- подписки сохраняются; +- slug не освобождается для создания нового канала. + +Канал автоматически возвращается в активное состояние при следующей новой самостоятельной публикации одного из типов: + +- `TEXT_POST (10)` +- `TEXT_REPOST (50)` +- `TEXT_ENTRYPOINT (100)` +- `TEXT_EXERCISE (110)` +- `TEXT_SERVICE (120)` +- `TEXT_COURSE (130)` + +`TEXT_CHANNEL_META` и `TEXT_EDIT_POST` состояние удаления не снимают. Отдельного `CHANNEL_RESTORE` нет. + +## SQL-проекция + +`channel_names_state` хранит только производное текущее состояние: + +```text +is_deleted BOOLEAN NOT NULL DEFAULT FALSE +deleted_at_ms BIGINT NOT NULL DEFAULT 0 +deleted_block_number INTEGER +``` + +Для активного канала: `is_deleted=false`, `deleted_at_ms=0`, `deleted_block_number=NULL`. + +Для удалённого: `is_deleted=true`, `deleted_at_ms` содержит timestamp delete-блока в миллисекундах, `deleted_block_number` — его глобальный номер. + +Эти поля не являются источником истины: bootstrap/rebuild обязан детерминированно восстановить их из канонических blockchain-блоков. Это правило действует и для каналов, root которых создан в более раннем fork: логический владелец определяется по `login`, а физический `owner_bch_name` root сохраняется как часть selector канала. + +## UI / counters + +- обычные списки скрывают `deleted` каналы; +- профиль может запросить их через `includeDeleted=true`; +- сам канал остаётся доступен и помечается как удалённый; +- deleted-каналы не входят в обычные channel counters и общий unread; +- подписки при soft-delete не удаляются. diff --git a/docs/Blockchain/18_KEY_ROTATION_AND_FORK_TARGETS.md b/docs/Blockchain/18_KEY_ROTATION_AND_FORK_TARGETS.md new file mode 100644 index 00000000..6c2bfb41 --- /dev/null +++ b/docs/Blockchain/18_KEY_ROTATION_AND_FORK_TARGETS.md @@ -0,0 +1,77 @@ +# Key rotation, fork и логические ссылки + +Этот документ фиксирует протокольную семантику fork. API-последовательность ротации описана отдельно в `docs/API/19_Key_Rotation_API.md`. + +## 1. Идентичности + +- Пользователь: `login`. +- Физическая ветка: `login-forkNumber` (`1..999`, формат имени строго три цифры: `001..999`; fork `1000` и выше запрещён). +- Активный fork определяется текущим PDA. +- Исторические fork остаются проверяемыми. + +## 2. HEADER + +Block 0 новой пользовательской истории — `HEADER`: + +```text +SHiNE + login + initialBlockchainKey32 +``` + +`initialBlockchainKey32` — public blockchain-signing key fork №1. Это только историческая запись происхождения цепочки. При смене ключа сохранённый префикс, включая HEADER, перепубликуется с тем же Frame; поле остаётся исходным ключом и не сравнивается с текущим ключом fork. Текущий ключ конкретного fork определяется подписью/owner и PDA. + +## 3. Внешний target + +Для REPLY, RATING, REPOST, LIKE/UNLIKE, CONNECTION, STATUS_ACTION: + +```text +[1] toLoginLen +[N] toLogin UTF-8 +[2] toForkNumber uint16 +[4] toBlockGlobalNumber +[32] toBlockHash32 +``` + +`toForkNumber` — информационная историческая метка: fork, на который смотрел автор действия. Допустимы только реальные fork `1..999`; `0` запрещён. Поле не участвует в identity и не должно сравниваться с текущим active fork как условие валидности. + +Логическая identity цели: + +```text +toLogin + toBlockGlobalNumber + toBlockHash32 +``` + +Если сохранённый префикс перепубликован в новом fork байт-в-байт, номер блока и SHA-256(Frame) совпадают, поэтому внешняя ссылка продолжает указывать на тот же логический блок. + +## 4. Собственный edit + +EDIT_POST и EDIT_REPLY относятся только к собственному blockchain и используют: + +```text +[4] toBlockGlobalNumber +[32] toBlockHash32 +``` + +Login/fork не хранятся. Целевой оригинальный блок должен существовать в текущей ветке с тем же hash. Блок, отброшенный rollback и отсутствующий в новом active fork, редактировать из новой ветки нельзя. + +## 5. CONNECTION на пользователя + +Связь на пользователя всегда указывает на его реальный HEADER: + +```text +toLogin = target login +toBlockGlobalNumber = 0 +toBlockHash32 = SHA-256(target HEADER Frame) +``` + +Нулевой hash как sentinel запрещён. + +## 6. Что переносится при fork + +Для сохранённого префикса Frame не меняется. Могут измениться внешняя ANS-104 подпись, owner/DataItem ID, но SHiNE block hash (`SHA-256(Frame)`) остаётся прежним. Поэтому `number + hash` является устойчивой частью ссылки. + +`toForkNumber` старого действия не переписывается после fork: это исторический факт момента создания действия. + +## 7. Серверная модель Stage 2 + +Stage 2 больше не хранит physical target name как identity. `blocks_store` хранит физическую ветку как `(login, fork_number)`, а `reactions_state`, `message_stats`, `connections_state` и просмотры адресуют цель логически через `login + blockNumber + hash`. Поэтому при смене active fork никакого массового rebind `old_bch_name -> new_bch_name` не выполняется. + +Если `number + hash` сохранились после fork, внешние состояния продолжают относиться к той же цели автоматически. Если hash изменился после rollback, это новая логическая цель. diff --git a/docs/Blockchain/19_STAGE2_LOGICAL_TARGETS_AND_FORK_STORAGE.md b/docs/Blockchain/19_STAGE2_LOGICAL_TARGETS_AND_FORK_STORAGE.md new file mode 100644 index 00000000..dda44735 --- /dev/null +++ b/docs/Blockchain/19_STAGE2_LOGICAL_TARGETS_AND_FORK_STORAGE.md @@ -0,0 +1,62 @@ +# Stage 2 — logical targets and numeric fork storage + +## Canonical identities + +Physical fork identity is `(login, fork_number)`, where `fork_number` is strictly `1..999`. `login-NNN` is a derived presentation value only; `1000+` is invalid. + +A logical external target is `(to_login, to_block_number, to_block_hash)`. `to_fork_number` remains signed historical metadata but MUST NOT participate in equality, validity, LIKE aggregation, CONNECTION identity, or fork rebinding. + +## Tables + +- `blocks_store`: stores `login + fork_number`; does not store `bch_name` or `to_bch_name`. +- `blockchain_state_store`: keyed by `(login,fork_number)`. +- compatibility SQL views `blocks` and `blockchain_state` derive `login-NNN` for old read/API paths; the name is not persisted. +- `reactions_state`: current actor LIKE/UNLIKE state keyed by actor login + logical target. +- `message_stats`: logical target counters. It may exist before the target block is locally available. +- `connections_state`: logical targets only. +- `message_views_state`: viewer + logical target. + +## LIKE before target + +A valid LIKE is projected even when the target block has not arrived. `message_stats` is created for the logical target. When the target later arrives, it reads the already existing counters by `login + blockNumber + hash`. + +## Fork behaviour + +If a prefix is republished unchanged, its Frame hash remains unchanged, so incoming social state is automatically reused. No rebind is performed. + +If rollback replaces a block with the same number but a different hash, the new block has separate stats. Old stats may remain as historical/orphaned state and do not attach to the replacement. + +## Atomic cleanup before replay + +`REBUILDING_SERVER` is set before cleanup/replay. Cleanup is one SQL transaction: + +1. collect active LIKE targets of the actor; +2. remove actor rows from `reactions_state`; +3. recount only affected LIKE counters (all/official/shining); +4. remove actor outgoing `connections_state`, refresh affected target-user/channel stats, and reset actor-derived profile/state; +5. delete physical blocks for `(login,fork_number)`; +6. delete physical blockchain state for `(login,fork_number)`; +7. commit. + +Incoming `message_stats` for the user's targets are never deleted. Candidate blocks are then replayed normally. A crash leaves rotation in `REBUILDING_SERVER`, so rebuild can be retried. + +## REPLY + +Stage 2 does not redesign REPLY. Only the unavoidable database-column adaptation uses the logical target key after `to_bch_name` removal; no new REPLY UI/resolver/cleanup behaviour is introduced. + +## EDIT + +EDIT remains own-chain only. EDIT blocks disappear with their physical fork and return through replay. `edits_count` is not part of Stage 2 message aggregates. + +## Database bootstrap / DB v2 marker + +Stage 2 uses a new database generation explicitly marked as **`SHiNE_DB_V2`** (`database_generation=2`) in `shine_database_metadata`. The runtime schema revision is `29`. + +Stage 2 is installed only on a clean PostgreSQL schema. The final schema is created directly by `schema_v1.sql`; there is no `migration_v29.sql`. Both the server bootstrapper and the SQL bootstrap script reject a non-empty/legacy database instead of modifying or migrating it. + +At every server start, both conditions are required: + +- `shine_database_metadata.id=1`, `database_format='SHiNE_DB_V2'`, `database_generation=2`; +- `db_schema_version.id=1`, `schema_version=29`. + +If an old SHiNE database is configured accidentally, server startup fails with an explicit legacy/non-v2 database error. diff --git a/docs/Blockchain/CHANGELOG.md b/docs/Blockchain/CHANGELOG.md index bc247cb5..990c166f 100644 --- a/docs/Blockchain/CHANGELOG.md +++ b/docs/Blockchain/CHANGELOG.md @@ -1,3 +1,49 @@ +## 2026-10-06 18:02 +0300 — Soft-delete каналов + +- Базовый коммит-ориентир: `working tree`; изменение подготовлено как patch без нового git-коммита. +- Добавлен line-based `TEXT_CHANNEL_DELETE (type=1, subType=92, version=1)` с обязательным пустым text. +- `TEXT_CHANNEL_DELETE` становится обычным хвостом линии канала и сохраняет обязательный ANS-104 tag `c=`. +- В `channel_names_state` добавлены только `is_deleted`, `deleted_at_ms`, `deleted_block_number`; delete-hash отдельно не хранится. +- Новый самостоятельный `TEXT_POST/REPOST/ENTRYPOINT/EXERCISE/SERVICE/COURSE` автоматически оживляет канал; `TEXT_CHANNEL_META` и `TEXT_EDIT_POST` состояние удаления не меняют. +- Soft-deleted канал сохраняет root, slug, историю, старые ссылки и подписки; slug не освобождается. Обычные списки/counters/unread deleted-каналы скрывают, а `ListUserProfileChannels.includeDeleted=true` позволяет показать их в профиле. +- Bootstrap/rebuild восстанавливает delete-state из канонической истории с учётом segmented forks по логическому `login`, поэтому root из старого fork остаётся валидным. +- Схема PostgreSQL поднята до v31; добавлен безопасный переход v30 -> v31. + +## 2026-10-07 — Public files на access server + +- Отдельные preview-файлы вложений выведены из текущего протокола и UI. `preAr/preSha256` и `previewAr/previewSha256` больше не создаются и не используются. +- Для `S:att v=1` источник определяется наличием `ar`: `ar` есть -> Arweave; `ar` отсутствует -> public file текущего сервера доступа автора по `/files/`. +- Добавлено публичное content-addressed хранение исходных байтов на access server: один глобальный объект на lowercase hex SHA-256, дедупликация между пользователями, signed `PUT /files/`. Адрес сервера, MIME и owner в блок не добавляются. +- UI каналов получил выбор `Сервер доступа` / `Arweave`; сервер доступа выбран по умолчанию. Для server-вложения клиент определяет актуальный access server автора по PDA. + +## 2026-10-02 — Transport namespace `test5591` + +- Текущий ANS-104 namespace переключён с `test5590` на `test5591`: `App=test5591`; channel index теперь постоянный и не зависит от namespace: `c=`. +- Namespace хранится отдельно в трёх рабочих местах: сервер, UI и актуальный `shine-UI/static-sites/arweave-viewer`; это намеренная простая конфигурация без cross-module runtime-зависимости. +- Сервер, UI и актуальный Viewer используют свои локальные константы namespace; общего cross-module `protocol-config` нет. +- Серверные AddBlock/key-rotation/archive-sync проверки больше не содержат захардкоженного `test5591`. +- Исторические упоминания `test5590` в старых changelog/legacy patch-документах оставлены как история предыдущего тестового namespace. +- Изменение рассчитано на новую чистую тестовую БД/цепочки; старые `App=test5590` DataItem новым namespace автоматически не подхватываются. +- Frame header увеличен с 56 до 88 bytes из-за `back32Hash32`; сервер проверяет N-32, Viewer показывает и проверяет резервную ссылку. + +## 2026-10-01 — Проверяемые USER_PROFILE / CONNECTION / TECH линии и signed `t` index + +- Тип `4` в документации называется `USER_PROFILE`; внутренние исторические имена классов могут сохраняться. USER_PROFILE предназначен только для данных профиля. +- `USER_PROFILE` и `CONNECTION` получили обязательную фиксированную line-схему без сериализованного `lineCode`: `prevBlockNumber + prevBlockHash32 + sequence`. Первый шаг ссылается на HEADER и имеет sequence `1`. +- `TECH_FORK` включён в общую TECH-линию вместе с `TECH_CREATE_CHANNEL`; оба используют `lineCode=0`, предыдущий TECH block/hash и `techSequence`. +- Серверная line-валидация стала строгой: новый блок обязан продолжать фактический текущий хвост той же линии и иметь sequence `+1`; произвольная ссылка на существующий блок больше не принимается. Это также устраняет боковую ветку канала после `EDIT_POST`. +- Добавлены подписанные ANS-104 индексы: `t=prof`, `t=conn`, `t=tech`. `STATUS_ACTION` не изменён. +- Единственным актуальным Viewer считается `shine-UI/static-sites/arweave-viewer`; старые корневые Viewer перенесены в его `history/legacy-root-viewers/`. +- В общий Frame добавлен глобальный `back32Hash32`: для блоков `#0..#31` нули, начиная с `#32` — SHA-256 Frame блока `N-32`. Отдельный back32 для line-body не добавляется. +- Формат USER_PROFILE/CONNECTION/TECH_FORK несовместим с предыдущей тестовой схемой; проект находится до production и миграция старых блоков не предусмотрена. + +## 2026-09-27 — TECH_FORK v1 + +- Добавлен `type=0 / subType=2 / version=1` (`TECH_FORK`). +- `TECH_FORK` фиксирует parent blockchain key, точку сохранённой истории, старый tip, число отброшенных блоков, reason code и пользовательский комментарий. +- Новый blockchain key не дублируется в body: он определяется подписью нового ANS-104 DataItem. +- Зафиксированы четыре причины: обычная ротация, возможная компрометация, подтверждённая компрометация с rollback и recovery. + # История изменений документации блокчейна ## 2026-09-23 — Turbo transport для individual ANS-104 DataItems @@ -264,3 +310,11 @@ - Старый custom `SHINE-ARCHIVE` pipeline удалён. Добавлены standard ANS-104 bundle publisher через существующий Arweave L1 uploader и GraphQL importer. - Импортированные из Arweave blocks не публикуются повторно; дедупликация идёт по `data_item_id`. - ESP32 и связанный device code этим изменением не затронуты. + +## 2026-10-07 — браузерный инспектор «Мой блокчейн» + +- Основание: patch archive, commit hash отсутствует. +- Формат блокчейна и серверный API не менялись. +- Экран «Мой блокчейн» теперь запрашивает уже существующее поле `blockBytesB64` и разбирает полный ANS-104 DataItem / SHiNE Frame v1 непосредственно в браузере. +- Для текущих TECH/TEXT/REACTION/CONNECTION/USER_PROFILE/STATUS_ACTION событий добавлены человекочитаемые подписи, компактный preview и раскрываемые детали. +- Arweave DataItem ID вычисляется локально как `SHA-256(signature64)` и используется для ссылки `https://arweave.net/`. diff --git a/docs/Blockchain/CODEX_APPLY_ANS104_TEST5590_PATCH.md b/docs/Blockchain/CODEX_APPLY_ANS104_TEST5590_PATCH.md index 791f37df..cadd6c8a 100644 --- a/docs/Blockchain/CODEX_APPLY_ANS104_TEST5590_PATCH.md +++ b/docs/Blockchain/CODEX_APPLY_ANS104_TEST5590_PATCH.md @@ -1,3 +1,5 @@ +> **LEGACY / historical patch note.** Current protocol uses `App=test5591` and the permanent channel tag `c=`. Do not apply the `c_test5590` instructions below to current code. + # Применение patch: Turbo + direct Arweave для `App=test5590` ## Что меняется @@ -9,6 +11,7 @@ - Importer всегда ищет только individual `App=test5590` DataItems. - `App=test5590-batch` больше не используется. - Channel tag: `c_test5590=` вместо `c=...`. +- Фиксированные signed indexes: `t=tech`, `t=conn`, `t=prof`. - Удалены `blocks.arweave_root_tx_id` и `arweave_block_import_queue.root_tx_id`. - Схема PostgreSQL: v25. diff --git a/docs/Blockchain/README.md b/docs/Blockchain/README.md index 30928277..e26ce663 100644 --- a/docs/Blockchain/README.md +++ b/docs/Blockchain/README.md @@ -5,6 +5,7 @@ ## Основные документы - [`01_Common_Block_Format.md`](01_Common_Block_Format.md) — точный Frame v1, ANS-104, подпись, хэши и теги. +- [`17_TEXT_Channel_Delete.md`](17_TEXT_Channel_Delete.md) — soft-delete канала через `TEXT_CHANNEL_DELETE=92` и правила автоматического оживления. - [`17_ANS104_Arweave_Transport.md`](17_ANS104_Arweave_Transport.md) — публикация блоков в Arweave и обратный импорт между серверами. - [`sync-between-servers.md`](sync-between-servers.md) — межсерверная синхронизация и full-resync без файловой копии blockchain. - [`CHANGELOG.md`](CHANGELOG.md) — история изменений протокола. @@ -14,7 +15,7 @@ ```text User -> создаёт Frame v1 - -> tags: App=test5590, при канале c_test5590= + -> tags: App=test5591; t=tech/conn/prof для фиксированных потоков; при канале c= -> Ed25519 подписывает ANS-104 deep-hash -> готовый DataItem -> AddBlock @@ -27,7 +28,7 @@ Server ИЛИ publish.mode=none: наружу не публиковать Other servers - -> GraphQL App=test5590 + -> GraphQL App=test5591 -> скачивают/извлекают DataItem -> verify -> PostgreSQL без повторной публикации @@ -38,4 +39,4 @@ Other servers - SHiNE `prevHash` остаётся SHA-256 предыдущего Frame v1 и не зависит от Arweave. - `data_item_id` нужен для Arweave, поиска и дедупликации. - PostgreSQL — единственное локальное хранилище пользовательских блоков. -- Тестовый namespace `App=test5590` специально отделён от будущего production namespace. +- Тестовый namespace `App=test5591` специально отделён от будущего production namespace. diff --git a/docs/Blockchain/TODO_BACK32_HASH.md b/docs/Blockchain/TODO_BACK32_HASH.md new file mode 100644 index 00000000..eebf7e20 --- /dev/null +++ b/docs/Blockchain/TODO_BACK32_HASH.md @@ -0,0 +1,51 @@ +# `back32Hash32` — глобальная резервная ссылка SHiNE + +Статус: **реализовано для общей пользовательской цепочки**. Отдельный `back32` для логических линий намеренно не добавляется. + +## Правило + +Каждый SHiNE Frame содержит: + +```text +[32] prevHash32 +[32] back32Hash32 +``` + +`prevHash32` остаётся основной соседней связью `N -> N-1`. + +`back32Hash32` — дополнительная резервная связь: + +```text +N < 32 -> ZERO_HASH_32 +N >= 32 -> SHA256(Frame блока N-32) +``` + +Номер блока для этой ссылки отдельно не хранится: он всегда равен `blockNumber - 32`. Поэтому дополнительных 4 байта номера нет. Стоимость механизма — **ровно +32 байта на каждый глобальный блок**. + +## Зачем + +Если соседний DataItem недоступен у конкретного gateway/CDN/сервера, обычная проверка через `prevHash32` прерывается. `back32Hash32` даёт второй криптографический мост к более ранней части истории. Это не восстанавливает отсутствующий блок и не доказывает его содержимое, но позволяет связать доступный последующий участок с историей на 32 блока раньше. + +Пример: + +```text +block #100 + prevHash32 -> HASH(#99) + back32Hash32 -> HASH(#68) +``` + +Для первых 32 блоков: + +```text +#0 ... #31 -> back32Hash32 = ZERO_HASH_32 +#32 -> HASH(#0) +#33 -> HASH(#1) +``` + +Сервер при `AddBlock` обязан сам проверить это поле по сохранённому блоку `N-32`; клиентское значение не принимается на доверии. + +## Почему без `back32` внутри линий + +CHANNEL / TECH / CONNECTION / USER_PROFILE уже имеют собственные `prev...BlockNumber`, `prev...Hash32` и sequence. Эти линии — дополнительный способ выборочной загрузки и проверки поверх основной пользовательской цепочки. Если в выборочно скачанной линии обнаружена дырка, блоки всё равно можно криптографически проверить через глобальную цепочку, где уже есть `prevHash32 + back32Hash32`. + +Поэтому добавлять ещё +32 байта в каждый line-based body сейчас нецелесообразно. Если когда-нибудь появится требование полностью проверять отдельный канал/профиль без доступа к глобальной цепочке даже через недоступный line-блок, line-back32 можно рассмотреть отдельной новой версией body. diff --git a/docs/Blockchain/sync-between-servers.md b/docs/Blockchain/sync-between-servers.md index 4d5d9849..60034925 100644 --- a/docs/Blockchain/sync-between-servers.md +++ b/docs/Blockchain/sync-between-servers.md @@ -40,7 +40,7 @@ blockchain.sync.enabled=false Дополнительно каждый сервер может независимо включить `ArweaveBlockSyncScheduler`. -Он ищет child DataItems по тестовому тегу `App=test5590`, проверяет их и импортирует через ту же бизнес-проверку AddBlock. Импортированные блоки не публикуются повторно. +Он ищет child DataItems по тестовому тегу `App=test5591`, проверяет их и импортирует через ту же бизнес-проверку AddBlock. Импортированные блоки не публикуются повторно. Если блоки обнаружены не по порядку, persistent queue оставляет более поздние блоки pending до появления предыдущих. diff --git a/docs/Keys/DERIVATION.md b/docs/Keys/DERIVATION.md index 468994ce..f6d26ec2 100644 --- a/docs/Keys/DERIVATION.md +++ b/docs/Keys/DERIVATION.md @@ -2,10 +2,10 @@ > **Статус: ИСТОЧНИК ИСТИНЫ (single source of truth) по конкретной деривации.** > Этот файл описывает, как из пароля получается секрет и как из секрета выводятся -> все ключи (root, blockchain, device/Solana, homeserver) — формулами, байт-в-байт. +> все ключи (root, blockchain, client, homeserver) — формулами, байт-в-байт. > Если в коде меняется деривация (формула секрета, параметры Argon2id, соль, формула > ключа, разделитель `|`, набор/имена суффиксов, формат homeserver-ключа, связь -> dev-ключ ↔ Solana-адрес) — **в том же изменении обязательно править этот документ**. +> blockchain key ↔ Solana-адрес) — **в том же изменении обязательно править этот документ**. > Роли и назначение ключей описаны отдельно в `docs/Keys/README.md` (архитектура). > Здесь — только механика. Документ намеренно краткий. @@ -55,29 +55,41 @@ seed(32) = SHA-256(material) | Ключ | Суффикс | Назначение (кратко) | |------|---------|---------------------| | root | `root.key` | Личность. Подписывает unsigned-часть PDA-записи (`RootKeyBlock`). | -| blockchain | `bch.key` | Подписывает `LastBlockState` персонального блокчейна (`blockchain_public_key`). | -| device / **Solana** | `client.key` | Ключ устройства = Solana-ключ. Fee payer и подпись Solana-транзакций; адрес кошелька = `base58(clientPub)`. См. §3. | +| blockchain | `blockchain.key` | Подписывает пользовательские блоки/ANS-104 DataItem и является каноническим источником пользовательских кошельков: Solana и Arweave SAWD-v1. | +| client | `client.key` | Общий клиентский ключ для входа на сервер, устройств и DM. Не используется как источник штатных кошельков. | | homeserver | `homeserver.key:<имя>` | Ключ homeserver-устройства, по одному на каждый homeserver (различитель — имя). См. §4. | Полные роли каждого ключа — в `docs/Keys/README.md`. --- -## 3. Solana-ключ +## 3. Solana-кошелёк и authority -Отдельного «солана-ключа» нет. На Solana работают два ключа: +Отдельного «solana.key» нет. В актуальной модели Solana-wallet пользователя — **активный `blockchain.key`**: -- **`client.key` (device) — пополняемый кошелёк и fee payer.** Solana-адрес = `base58(clientPub)`. - Этим ключом оплачиваются и подписываются `create_user_pda` / `update_user_pda`. - Пополнять SOL нужно именно на этот адрес. -- **`root.key` — авторитет записи**, подписывает unsigned-часть PDA через Ed25519-инструкцию, но **не** является fee payer. +- адрес кошелька = `base58(activeBlockchainPub)`; +- им оплачивается регистрация (`create_user_pda`) и обычные `update_user_pda`; +- обычное обновление PDA авторизуется активным blockchain key; +- новый fork подписывает новое PDA новым blockchain key, а старый активный blockchain key разрешает обычный переход; +- полная смена пароля/ключей — особый recovery-переход: старый `root.key` дополнительно разрешает одно новое unsigned PDA state, а **новый blockchain key** подписывает тот же hash и становится новым wallet/authority. -Соответствует формату PDA `shine-solana/shine/doc/formats/shine-user-pda-format-v.1.0.md` §2.1 -(«create/update оплачиваются с `client_key`», «root_key — не fee payer»). +`root.key` не является fee payer. Он используется как холодное дополнительное разрешение только для полной ротации root + client + blockchain fork. -Кратко про роли на Solana: `root.key` — это **главный (master) ключ**: им управляют PDA-записью -(`create/update`) и через это можно заменить все остальные ключи; `client.key` — это **пополняемый -кошелёк и плательщик комиссий**. Полное описание ролей — `docs/Keys/README.md`. +`client.key` не используется как wallet/fee payer. Он остаётся клиентским криптографическим ключом для серверной авторизации, устройств и DM. Нативный Arweave SAWD-v1 wallet теперь детерминированно выводится из активного `blockchain.key`, как и Solana-wallet. + +При fork адреса кошельков меняются вместе с blockchain key. В UI ротации реализован отдельный этап переноса доступного SOL со старого blockchain-wallet на новый за вычетом комиссии сети. Перенос AR/Turbo при ротации пока отмечен отдельным TODO. + + +## 3.1. Хранение приватных ключей в текущем UI + +После обычного входа или подключения нового доверенного устройства UI автоматически сохраняет в зашифрованном локальном контейнере два рабочих приватных ключа: + +- `blockchain.key`; +- `client.key`. + +Приватный `root.key` (Recovery key) **никогда не сохраняется** в IndexedDB/localStorage и **никогда не передаётся** при pairing/QR. Для операций, которым он нужен по текущему Solana-протоколу, root временно выводится из введённого пользователем пароля и существует только в оперативной памяти процесса. Публичный root key, записанный в PDA, этим правилом не затрагивается. + +Ограниченный режим устройства архитектурно возможен благодаря разделению ключей, но в текущем релизе не включён: обычное авторизованное устройство всегда получает и хранит оба рабочих ключа. --- @@ -117,9 +129,9 @@ homeserver.key:home-b -> ключ B - `shine-UI/server-ui/js/server-ui-shared.js` — те же root/bch/dev для серверного UI (~147–160). ### Solana-ключ / адрес кошелька (UI) -- `shine-UI/js/pages/registration-payment-view.js` — `deriveUserWalletAddress`: адрес = `base58(clientPub)` (~113). -- `shine-UI/js/pages/topup-view.js` — `clientWalletAddressFromBundle`: тот же канонический адрес из `preGeneratedKeyBundle.clientPair`. - Прежний расходящийся путь `deriveWalletFromPassword` (прямой Argon2 по `client.key`, мимо `masterSecret`) удалён. +- `shine-UI/js/pages/registration-payment-view.js` — адрес пополнения = `base58(blockchainPub)`. +- `shine-UI/js/pages/topup-view.js` — тот же адрес из `preGeneratedKeyBundle.blockchainPair`. +- `shine-UI/js/services/solana-wallet-service.js` — текущий пользовательский Solana-wallet загружается из сохранённого `blockchainKey`. ### Деривация ключей (прошивка ESP32) - `ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/main-device/shine_homeserver_main/shine_homeserver_main.ino` @@ -147,7 +159,7 @@ homeserver.key:home-b -> ключ B 1. Этот документ — источник истины по деривации секрета и ключей. 2. Любое изменение кода, затрагивающее формулу секрета, параметры Argon2id, соль, формулу ключа, - разделитель `|`, набор/имена суффиксов, формат homeserver-ключа или связь dev-ключ ↔ Solana-адрес — + разделитель `|`, набор/имена суффиксов, формат homeserver-ключа или связь blockchain key ↔ Solana-адрес — **обязательно** отражать здесь в том же изменении. 3. Пункты, помеченные ⚠️, — это долг к устранению, а не норма. 4. Нельзя сознательно оставлять код и этот документ в рассинхроне без отдельной явной договорённости. diff --git a/docs/Keys/README.md b/docs/Keys/README.md index 14fcc1bd..757a36fd 100644 --- a/docs/Keys/README.md +++ b/docs/Keys/README.md @@ -8,29 +8,26 @@ В SHiNE у пользователя есть несколько уровней ключей: -- `root key` - главный (master) ключ пользователя: тот, кто им владеет, управляет пользовательской PDA в Solana и может заменить все остальные ключи. Это не пополняемый кошелёк (комиссии платит `client key`). -- `blockchain key` - ключ записи в персональный SHiNE-блокчейн пользователя. -- `client key` - общий ключ пользовательских устройств для повседневной работы, звонков, DM и мелких платежей. +- `root key` / **ключ восстановления** - recovery-authority. Его приватная часть не хранится на устройствах и временно выводится из пароля только для операций, где нужна по текущему протоколу. Это не кошелёк. +- `blockchain key` / **ключ блокчейна** - постоянно хранимый рабочий ключ записи в персональный SHiNE-блокчейн и канонический источник пользовательских кошельков (Solana, Arweave SAWD-v1, Turbo через Solana). +- `client key` / **ключ доступа** - постоянно хранимый рабочий ключ для входа на сервер, устройства, звонков и DM. Кошельки из него не выводятся. - `session key` - ключ конкретной сессии или конкретного устройства для авторизации на сервере. -Главная идея: самые важные ключи можно держать на доверенном серверном или аппаратном устройстве, а обычные клиентские устройства получают только ключи, нужные для текущей работы. +В текущем релизе обычное авторизованное устройство автоматически хранит два рабочих ключа: `blockchain key` и `client key`. Ограниченного режима пока нет. Приватный `root key` не сохраняется и не передаётся между устройствами. ## `root key` -`root key` - главный ключ пользователя. +`root key` - ключ восстановления пользователя. Его приватная часть не является постоянно сохранённым ключом устройства. Назначение: -- регистрация пользователя в Solana; -- создание и обновление пользовательской PDA-записи; -- вызов критически важных Solana-функций; -- изменение главных настроек пользователя; -- управление остальными ключами; -- подтверждение операций, которые должны иметь максимальный уровень доверия. +- холодное recovery-разрешение для полной смены ключей; +- подтверждение атомарной ротации `root + client + новый blockchain fork`; +- восстановительные сценарии повышенного уровня доверия. -`root key` — это **главный (master) ключ** в следующем смысле: зная `root key`, можно управлять пользовательской PDA-записью в Solana (`create_user_pda` / `update_user_pda`) и тем самым **заменить все остальные ключи** пользователя (device, blockchain, homeserver). Поэтому компрометация `root key` равносильна компрометации всей личности пользователя. +Обычные PDA-update **не требуют root key**: их выполняет активный blockchain key. При полной ротации старый root подписывает тот же hash нового unsigned PDA state, который подписывает новый blockchain key. Так root разрешает переход, не становясь повседневным ключом. -Важно не путать авторитет и кошелёк: `root key` — это авторитет над PDA-записью, а **SOL-комиссии за create/update платит `client key`** (он же fee payer и адрес для пополнения). Подробнее о том, какой ключ за что отвечает на Solana, — в `docs/Keys/DERIVATION.md`, §3. +Важно не путать recovery-authority и кошелёк: `root key` не является fee payer. Его публичная часть хранится в PDA, а приватная часть в текущем UI выводится из пароля только на время защищённой операции и затем не сохраняется. Текущий Solana-wallet/fee payer — активный `blockchain key`. Подробнее — `docs/Keys/DERIVATION.md`, §3. ## `blockchain key` @@ -40,7 +37,10 @@ - подпись записей в персональном блокчейне пользователя; - подтверждение действий, которые должны попасть в SHiNE-блокчейн; -- разделение полномочий между главным Solana-ключом и ключом ежедневной записи. +- обычные обновления пользовательской PDA; +- текущий Solana-wallet/fee payer (`base58(active blockchain public key)`); +- источник штатного Arweave SAWD-v1 wallet; +- ключ Solana-кошелька, которым пополняется Turbo. У пользователя может быть несколько персональных блокчейнов или веток. При смене `blockchain key` фактически создаётся новая ветка записи: @@ -48,6 +48,8 @@ - `username-002` - вторая ветка; - `username-003` - третья ветка. +Номер fork ограничен диапазоном `001..999`; после `username-999` новая ротация blockchain key не создаётся. + Рабочая логика по умолчанию должна использовать последнюю актуальную ветку. Старые ветки остаются читаемыми и показывают историю смены ключей. ## `client key` @@ -58,16 +60,9 @@ - повседневные входящие и исходящие личные сообщения; - звонки и связанные с ними сообщения; -- self-messages, то есть внутренние сообщения пользователя самому себе; -- мелкие Solana-расходы на текущие операции; -- derivation Arweave-кошелька; -- оплата или подготовка добавления данных в Arweave-кошелек по отдельному протоколу. +- self-messages, то есть внутренние сообщения пользователя самому себе. -Arweave-кошелёк должен выводиться из `client key` по протоколу: - -- `docs/Протоколы/SHINE_ARWEAVE_DERIVATION_V1.md` - -Если пользователь теряет только `client key`, в худшем случае ломается повседневная переписка и доступ конкретных устройств к ежедневным операциям. `root key` и `blockchain key` при правильной архитектуре остаются отдельно защищёнными. +Штатные кошельки из `client key` не выводятся. Arweave SAWD-v1 использует `blockchain key`: `docs/Протоколы/SHINE_ARWEAVE_DERIVATION_V1.md`. ## `session key` @@ -83,7 +78,7 @@ Arweave-кошелёк должен выводиться из `client key` по - авторизация сессии на сервере; - привязка устройства к пользователю; - подтверждение запросов от конкретной сессии; -- доступ к зашифрованному `client key` после успешной авторизации. +- доступ к локально зашифрованным рабочим ключам (`client key` и `blockchain key`) после успешной авторизации. Одна и та же сессия может быть пригодна для подключения к нескольким серверам пользователя, если архитектура конкретного пользователя это допускает. @@ -103,22 +98,16 @@ Arweave-кошелёк должен выводиться из `client key` по - обычная пользовательская сессия; - серверная сессия; -- аппаратная или доверенная сессия с доступом к расширенным ключам. +- аппаратная или доверенная сессия для будущих специализированных сценариев. -Обычное устройство обычно имеет: +Обычное авторизованное устройство в текущем релизе имеет: - собственный `session key`; -- зашифрованный `client key`, который открывается после авторизации; -- доступ к DM, звонкам и обычным пользовательским операциям. +- зашифрованный `client key`; +- зашифрованный `blockchain key`; +- доступ к DM, блокчейн-действиям и пользовательским кошелькам. -Доверенное серверное или аппаратное устройство может иметь: - -- `root key`; -- `blockchain key`; -- `client key`; -- собственный `session key`. - -Такая сессия может подписывать операции повышенной важности по запросам пользователя. +Приватный `root key` не хранится даже на обычном доверенном устройстве и не передаётся при подключении другого устройства. Будущий аппаратный режим может расширить эту модель отдельно, но текущий UI такого режима не включает. ## Внутренние self-messages @@ -127,7 +116,7 @@ Self-message - это сообщение пользователя самому Такие сообщения нужны, чтобы обычное устройство могло попросить доверенное устройство выполнить действие: - подписать запись `blockchain key` и передать её в SHiNE-блокчейн; -- подписать изменение настройки через `root key`; +- инициировать защищённую настройку, после чего Recovery key при необходимости должен быть временно выведен из пароля на устройстве пользователя; - обновить ключи; - сохранить внутреннюю команду или настройку; - отправить сообщение другому пользователю с сохранением копии себе; @@ -158,13 +147,13 @@ Self-message - это сообщение пользователя самому ## Связанные документы -- `docs/Keys/DERIVATION.md` - **источник истины по конкретной деривации** секрета и ключей (формулы Argon2id, `base64|suffix→SHA-256→Ed25519`, суффиксы `root.key`/`bch.key`/`client.key`/`homeserver.key:<имя>`, Solana-ключ, ссылки на код). +- `docs/Keys/DERIVATION.md` - **источник истины по конкретной деривации** секрета и ключей (формулы Argon2id, `base64|suffix→SHA-256→Ed25519`, суффиксы `root.key`/`blockchain.key`/`client.key`/`homeserver.key:<имя>`, Solana-wallet, ссылки на код). - `docs/Personal_Messages/Протокол_DM_v1.md` - текущая логическая документация личных сообщений. - `docs/Personal_Messages/Формат_DM_v1.md` - точный байтовый формат личных сообщений. - `docs/Blockchain/README.md` - точка входа по форматам SHiNE-блокчейна. - `docs/Solana_Architecture/README.md` - архитектура Solana-программ, PDA-счетов, DAO и движения средств. - `docs/Инициализация_Solana_регистрации/README.md` - деплой и первичная инициализация Solana-регистрации. -- `docs/Протоколы/SHINE_ARWEAVE_DERIVATION_V1.md` - derivation Arweave-кошелька из `client key`. +- `docs/Протоколы/SHINE_ARWEAVE_DERIVATION_V1.md` - derivation Arweave-кошелька из `blockchain key`. ## Что нужно уточнить перед реализацией diff --git a/docs/Personal_Messages/README.md b/docs/Personal_Messages/README.md index 1c7f5f21..5c72c2f0 100644 --- a/docs/Personal_Messages/README.md +++ b/docs/Personal_Messages/README.md @@ -33,3 +33,7 @@ - сервер файлов ключ расшифрования не получает. Формат бинарного контейнера `SHiNE_DM` при этом не меняется. + +### Key rotation и локальный архив DM + +При смене client key старые `type=1/2` локальные копии перешифровываются клиентом пакетами. Критерий незавершённой миграции — локальная копия была сохранена до cutoff входа в `MESSAGE_MIGRATION` и имеет `reencryptedAtMs < cutoff`. Повторная отправка на сервер собеседника не выполняется. Для перешифрованного входящего `type=1` подпись принадлежит получателю; это локальная мигрированная копия, а не сохранённая подпись первоначального отправителя. diff --git a/docs/Personal_Messages/Протокол_DM_v1.md b/docs/Personal_Messages/Протокол_DM_v1.md index 36bb8c59..75319d4d 100644 --- a/docs/Personal_Messages/Протокол_DM_v1.md +++ b/docs/Personal_Messages/Протокол_DM_v1.md @@ -262,3 +262,11 @@ DeleteMessage принимает type=5/6. DeleteConversation принимает - исходный `` не переносится, поэтому новое сообщение не остаётся ответом на сообщение из старого чата; - для сообщения с файлами повторно используются существующие ``-описатели, поэтому ciphertext не шифруется и не загружается повторно; - сервер и получатель видят пересланное сообщение как обычное новое сообщение без служебной пометки об источнике. + +## Перешифровка локального архива при смене client key (06.10.2026) + +При key rotation сервер собеседника повторно не уведомляется. Меняются только локальные копии `type=1` и `type=2` на access-сервере владельца архива. + +`reencryptedAtMs=0` означает обычную исходную копию. При входе rotation в `MESSAGE_MIGRATION` её `updatedAtMs` фиксирует cutoff текущей миграции. Старые локальные копии, сохранённые до cutoff, получают `reencryptedAtMs=cutoff`. Следующая ротация использует уже свой новый cutoff. + +Правило подписи `type=1` зависит от `reencryptedAtMs`: исходная входящая копия (`0`) подписана отправителем; локально перешифрованная входящая копия (`>0`) подписывается новым client key получателя. `type=2` остаётся подписанным владельцем исходящей локальной копии (`fromLogin`). Перешифрованная копия предназначена для локального восстановления содержимого новым client key и не считается сохранением первоначальной подписи отправителя. diff --git a/docs/Personal_Messages/Формат_DM_v1.md b/docs/Personal_Messages/Формат_DM_v1.md index 88e170d5..b1fb8ad8 100644 --- a/docs/Personal_Messages/Формат_DM_v1.md +++ b/docs/Personal_Messages/Формат_DM_v1.md @@ -317,7 +317,9 @@ UI-примечание (байтовый формат не меняет): ра Правило подписи по `messageType`: -- `1`, `2`, `5`, `7` подписывает отправитель сообщения; +- `1` при `reencryptedAtMs = 0` подписывает исходный отправитель сообщения; +- `1` при `reencryptedAtMs > 0` — это локальная перешифрованная копия, её подписывает получатель; +- `2`, `5`, `7` подписывает отправитель сообщения; - `6`, `8` подписывает получатель сообщения. Практическое UI-следствие: @@ -393,3 +395,13 @@ UI-примечание (байтовый формат не меняет): ра - информация о том, из какого чата или сообщения выполнена пересылка, в контейнер не добавляется. Таким образом подпись, `baseKey`, шифрование и структура контейнера остаются полностью прежними: меняется только содержимое нового plaintext перед стандартной отправкой. + +## Семантика `reencryptedAtMs` и подписи при key rotation (06.10.2026) + +Байтовый формат `SHiNE_DM v1.0` не изменяется. Поле `reencryptedAtMs` используется как эпоха локальной перешифровки. + +- `type=1`, `reencryptedAtMs == 0`: подпись проверяется по `clientKey` `fromLogin`. +- `type=1`, `reencryptedAtMs > 0`: подпись проверяется по `clientKey` `toLogin`; ciphertext зашифрован на новый client key получателя. +- `type=2`: подпись проверяется по `clientKey` `fromLogin`; при миграции ciphertext локальной исходящей копии также шифруется на новый client key владельца. + +При перешифровке сохраняются `fromLogin`, `toLogin`, `timeMs`, `nonce`, `messageType` и `revisionTimeMs`; меняются encrypted body, подпись и `reencryptedAtMs`. diff --git a/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md b/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md index 0bcad4c4..6b635ee5 100644 --- a/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md +++ b/docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md @@ -579,8 +579,33 @@ SYNC_POLL_INTERVAL_SECONDS=300 - `ServerProfileBlock` в 1.2 допускает один адрес сервера, `AccessServersBlock` — 0 или 1 access server; - в compatibility SQL-поля проецируется **последний** fork как активный `blockchain_key/paid_limit_bytes`; - полный список fork сохраняется в `blockchain_forks_json`, поэтому поиск пользователя по старому blockchain key остаётся возможным; -- `blockchain_name` для compatibility view вычисляется как `-NNN`, где `NNN` соответствует индексу fork + 1; +- `blockchain_name` для compatibility view вычисляется как `-NNN`, где `NNN` соответствует номеру fork `001..999`; PDA с `fork_count > 999` сервером не принимается; - удалённые tip-поля (`used_bytes`, `last_block_*`, Arweave tx id) в PDA 1.2 больше не являются источником истины и в compatibility snapshot заполняются нейтральными значениями; - server profile считается присутствующим, если опубликован один server address; в старые SQL-поля временно проецируется этот адрес. Create/update транзакции больше не реконструируются байт-в-байт из instruction args. После обнаружения изменения sync-модуль перечитывает фактическую текущую PDA через Solana RPC и декодирует её. Это исключает дублирование on-chain сериализации. `close_legacy_pda` не создаёт новое состояние PDA и для runtime-sync не является пользовательским update. + +--- + +## Server-local key rotation state (PostgreSQL v26) + +Начиная с migration v26 сервер хранит локальное состояние длительной смены ключей отдельно от данных Solana PDA. + +В `solana_user_pda_current` добавлены локальные поля: + +- `rotation_status` — быстрый текущий статус (`NONE` в обычном режиме); +- `rotation_session_id` — ссылка на текущую запись `key_rotation_sessions`. + +Эти поля **не являются частью PDA**, не приходят из Solana и не должны перезаписываться обычным Solana sync upsert-ом. + +Подробный прогресс хранится в `key_rotation_sessions`: только публичные old/new root/blockchain/client keys, выбранная точка fork, старый tip, reason/comment, прогресс, ошибка/retry и статусы необязательных wallet/DM этапов. Пароли и приватные ключи в PostgreSQL не сохраняются. + +Первая серверная запись создаётся сразу в `COPYING_CHAIN`; состояния `PREPARING` в БД нет. Завершённые `COMPLETE`/`ABORTED` sessions остаются как журнал, а `solana_user_pda_current.rotation_status` возвращается в `NONE`. + +### Candidate blocks ротации (PostgreSQL v27) + +Будущая ветка во время `COPYING_CHAIN` хранится в отдельной таблице `key_rotation_candidate_blocks`. Она не является частью текущего materialized blockchain state и не должна попадать в обычную `blocks` до финального переключения fork. + +Для каждого candidate DataItem сохраняются rotation session, login, candidate blockchain name, block number/hash, полный ANS-104 DataItem, DataItem id и статус публикации. Уникальность `(rotation_session_id, block_number)` запрещает две разные версии одного candidate-блока. + +Arweave/Turbo publisher обрабатывает candidate-блоки приоритетно. `key_rotation_sessions.progress_current` отражает число DataItem, уже реально опубликованных publisher-ом, а не число принятых API-сервером. diff --git a/docs/Solana_Architecture/details/shine_users.md b/docs/Solana_Architecture/details/shine_users.md index d3b92704..dd453bbb 100644 --- a/docs/Solana_Architecture/details/shine_users.md +++ b/docs/Solana_Architecture/details/shine_users.md @@ -16,7 +16,7 @@ Основные данные: - `RootKeyBlock` — cold recovery authority; -- `ClientKeyBlock` — клиентский/кошелёчный ключ; +- `ClientKeyBlock` — клиентский ключ для DM/устройств; Solana-wallet/fee payer — активный blockchain key; - `BlockchainRegistryBlock` — append-only список fork: `blockchain_key[32] + created_at_ms:u64 + paid_limit_bytes:u32`; последний fork активен; - необязательный `ServerProfileBlock` — в 1.2 ровно один адрес сервера; - необязательный `AccessServersBlock` — в 1.2 максимум один access server. diff --git a/docs/UI-Design/UI-v4-for-dev.md b/docs/UI-Design/UI-v4-for-dev.md new file mode 100644 index 00000000..9e978625 --- /dev/null +++ b/docs/UI-Design/UI-v4-for-dev.md @@ -0,0 +1,65 @@ +# UI v3–v4: что нужно от сервера и что знать разработчику + +Макет V3/V4 перенесён в настоящий код (v3) и доведён по экранам (v4): палитра «Сияние», лента канала, обсуждение, +личный чат, вход и регистрация, уведомления, настройки, просмотр фото. Всё сделано на текущем API без его изменений. +Там, где интерфейсу не хватает сервера, UI к этому готов: нет данных – элемент просто не появляется. + +## Нужно от сервера + +1. **Кто недавно ответил** – миниатюры рядом со счётчиком обсуждения в ленте канала. + Поле `recentRepliers: string[]` (до двух логинов, свежие первыми) у сообщений в `GetChannelMessages` + и `GetMessageThread`. UI: `channel-view.js`, `mapApiMessageToPost` → `recentRepliers`. Нет поля – нет миниатюр. + +2. **«Не уведомлять об ответах» в обсуждении.** Пункт меню обсуждения сейчас запоминает выбор только на устройстве + (`localStorage`, ключ `shine-ui-thread-muted-v1`) и на уведомления не влияет. Нужна настройка пользователя + «без уведомлений об ответах в этом обсуждении» (по ссылке на исходную запись), учитываемая при создании + уведомлений `reply`. Удобно через существующий `UpsertUserSetting`. + +3. **Ссылка на комментарий.** «Поделиться комментарием» даёт ссылку на обсуждение с якорем `#comment-`. + Роутер якорь игнорирует. Нужно: при открытии обсуждения с таким якорем прокрутить к комментарию и подсветить + (в UI для этого есть `jumpTo` в `channel-thread-view.js`). + +4. **Уведомления об ответах – на что ответили** (по желанию). В уведомлении есть только текст ответа (`sourceText`). + Чтобы показать «в ответ на: …», нужен короткий текст исходного сообщения (`targetText`) в `GetNotifications`. + +5. **Стоимость публикации** (экран «Публикация · подтверждение» макета). Шага подтверждения в приложении нет – + запись уходит сразу. Если публикация станет платной или будет ждать Arweave, нужна цена до отправки. + +## Нужно от разработчика + +6. **Удалить `pages/key-storage-view.js` и маршрут `/key-storage`.** Экран никуда не подключён: в поля вписаны + описания ключей, «OK» вызывает `authorizeSession()` без данных. Настоящий выбор ключей – `registration-keys-view.js` + (переделан в v4). Вместе с ним можно убрать `.key-storage-option*` / `.key-storage-note*` в `developer-tools.css`. + +## Что важно знать об изменениях v4 + +- **Второстепенные кнопки** – одна роль во всём приложении, включая экраны устройств и серверов: прозрачная, рамка, цвет `--action`. +- **Полоса прокрутки скрыта по умолчанию** (`scrollbar: 'hidden'` в режимах оболочки `app.js`) – как было у каналов, + ленты и обсуждения. Прокрутка работает, контент не прыгает при появлении полосы. +- **Один зазор под шапкой:** `--page-top-gap` в `main.css` (12 px). Его берут `app-shell.css`, каналы и экраны входа – + свои отступы сверху экранам не нужны. +- **Шапка корневых разделов** (Чаты, Каналы, Связи, Уведомления, Профиль) – заголовок по центру, 24 px (`.topbar--root`). +- **Переключатели `.tabs`** – высотой с поле ввода (44 px, кнопки 34 px); `.tabs--dense` – для 4–5 коротких пунктов + (фильтр чатов вместо чипов). +- **Новые общие компоненты:** `components/media-viewer.js` + `styles/components/media-viewer.css` (фото/видео на весь экран, + «1/3» и «Скачать» под фото; заменил `openAttachmentViewer` и кнопку скачивания на фото), `components/shine-wordmark.js` + (надпись «СИЯНИЕ» в контурах, шрифт Tenor Sans, OFL), переключатель `.switch` (перенесён из `settings.css` в `primitives.css`). +- **Иконки** – только из `ui-icon.js` (добавлены `eye`, `eyeOff`; `iconHtml(name, filled, className)`). Текстовые символы + вместо иконок («↻», «+», «✕») заменены. +- **«Дополнительные настройки»** теперь открываются пятью быстрыми нажатиями на заголовок «Настройки» + (логотип над настройками убран). +- **Стартовый экран:** знак по центру, кнопки внизу; сияние мандалы – два вращающихся слоя в `preauth.css` + (`.auth-logo-wrap::before/::after`), фаза случайная; при `prefers-reduced-motion` неподвижно. +- **Тексты:** в строках интерфейса только среднее тире с пробелами «–» (длинное «—» заменено везде, кроме комментариев). +- Уведомления – список как в чатах; «Настройки входа» – одна карточка серверов со статусом-пилюлей, проверка при открытии; + вход с другого устройства – код, таймер, три шага. + +## Найденные ошибки (не наши) + +7. `styles/components/avatar.css`: `url("../assets/glass_overlay_faithful.png")` ведёт в `styles/assets/…` – файла там нет, + стеклянный ободок аватара не загружается. Путь должен быть `../../assets/…`. +8. Обработчик ошибок в `index.html` показывал красную плашку «BOOT ERROR ResizeObserver loop…» – это предупреждение + браузера, не ошибка. В v3 отсеивается. +9. Пункты 1–2 из `ISSUES-for-dev.md` (подписки у логинов с заглавными, превью «Сообщение недоступно») по-прежнему актуальны. +10. Вход по паролю на `http://` по адресу в локальной сети не работает («Криптография браузера недоступна»): WebCrypto есть + только на https и localhost. Это ограничение браузера – для проверки с телефона нужен https. diff --git a/docs/Инициализация_Solana_регистрации/README.md b/docs/Инициализация_Solana_регистрации/README.md index 81eba6f7..955ff90d 100644 --- a/docs/Инициализация_Solana_регистрации/README.md +++ b/docs/Инициализация_Solana_регистрации/README.md @@ -90,14 +90,14 @@ ## Кто оплачивает create/update user_pda -- И обычная регистрация `create_user_pda`, и последующее `update_user_pda` оплачиваются с `clientKey`. -- В UI это означает, что Solana fee payer всегда берётся из `device`-ключа пользователя или сервера. -- `rootKey` нужен для подписи unsigned PDA-записи, но не оплачивает транзакцию. -- Для server UI это особенно важно: перед `create` и `update` нужно пополнять именно Solana-адрес `clientKey`. +- И обычная регистрация `create_user_pda`, и последующее `update_user_pda` оплачиваются с активного `blockchainKey`. +- В UI это означает, что Solana fee payer всегда берётся из текущего активного `blockchain key` пользователя или сервера. +- `rootKey` не оплачивает транзакцию; он дополнительно авторизует только полную ротацию ключей. +- Для server UI это особенно важно: перед `create` и `update` нужно пополнять именно Solana-адрес текущего `blockchainKey`. ## Важно - `init_users_economy_config` выполняется один раз на программу. Если PDA уже создан, повторный вызов вернёт ошибку `already initialized`. -- Серверные приватные ключи для Solana не используются как отдельный backend-wallet: транзакцию оплачивает `clientKey`, а содержимое записи подписывает `rootKey`. +- Серверные приватные ключи для Solana не используются как отдельный backend-wallet: транзакцию оплачивает `blockchainKey`. Обычное состояние PDA подписывает blockchain key; root дополнительно участвует только в полной ротации ключей. - `shine_users` внутри `create_user_pda` требует корректный адрес `shine_login_guard` для CPI-классификации логина. - При новом devnet deploy планируется использовать те же program keypair, чтобы `program id` на devnet совпадали с mainnet. diff --git a/docs/Протоколы/SHINE_ARWEAVE_DERIVATION_V1.md b/docs/Протоколы/SHINE_ARWEAVE_DERIVATION_V1.md index 25e48b47..95972dd9 100644 --- a/docs/Протоколы/SHINE_ARWEAVE_DERIVATION_V1.md +++ b/docs/Протоколы/SHINE_ARWEAVE_DERIVATION_V1.md @@ -3,11 +3,11 @@ Сокращение: **SAWD-v1**. ## Назначение -Из 32-байтного `clientKey32` пользователя получить один и тот же нативный Arweave RSA-4096 JWK wallet и один и тот же Arweave address. +Из 32-байтного приватного seed активного `blockchainKey32` пользователя получить один и тот же нативный Arweave RSA-4096 JWK wallet и один и тот же Arweave address. ## Вход -- `clientKey32`: ровно 32 байта. -- Если исходный `client.key` хранится как Ed25519 PKCS8 base64, нужно извлечь последние 32 байта из PKCS8. +- `blockchainKey32`: ровно 32 байта. +- Если исходный `blockchain.key` хранится как Ed25519 PKCS8 base64, нужно извлечь последние 32 байта из PKCS8. - Если используется Solana keypair JSON на 64 байта, используются только `bytes[0..31]`. ## Выход @@ -46,8 +46,8 @@ - `SMALL_PRIME_LIMIT = 10000` ## Алгоритм -1. Проверить `clientKey32.length == 32`. -2. `masterSeed32 = HMAC-SHA256(key = UTF8(MASTER_LABEL), message = clientKey32)`. +1. Проверить `blockchainKey32.length == 32`. +2. `masterSeed32 = HMAC-SHA256(key = UTF8(MASTER_LABEL), message = blockchainKey32)`. 3. Реализовать `deriveBytes(label, length)`: - `output = empty` - `counter = 0` @@ -71,9 +71,9 @@ - `baseBytes = HMAC-SHA256(key = masterSeed32, message = UTF8(MR_LABEL) || UTF8("/") || UTF8(label) || UTF8("/") || uint64_be(index) || UTF8("/") || uint32_be(round))` - `a = 2 + (unsigned_big_endian_integer(baseBytes) mod (candidate - 3))` 6. `p = derivePrime("p")`, `q = derivePrime("q")`. -7. Если `p == q`, продолжить поиск `q`. +7. Продолжать детерминированный поиск `q` (`q/index+1`, `q/index+2`, ...), если `p == q` **или** `bitLength(p * q) != 4096`. Это гарантирует настоящий 4096-битный RSA modulus, а не допустимый математически, но неподходящий для стандарта 4095-битный product двух 2048-битных простых. 8. Если `p > q`, поменять местами. В SAWD-v1 всегда `p < q`. -9. `n = p * q` +9. `n = p * q`; обязательно `bitLength(n) == 4096` 10. `e = 65537` 11. `lambda = lcm(p - 1, q - 1)` 12. `d = modular_inverse(e, lambda)` @@ -101,4 +101,4 @@ ## Версионирование стандарта Если меняется любая константа или шаг алгоритма — это уже **SAWD-v2**. -Пользователи, созданные на SAWD-v1, должны продолжать восстанавливаться через SAWD-v1. +До публичного запуска legacy-совместимость не требуется. После запуска источник и алгоритм SAWD-v1 считаются частью стабильного формата: изменение источника ключа или любой константы потребует новой версии стандарта. diff --git a/docs/Черновики/Черновик_дополнений_каналов_и_типов_сообщений_SHiNE.md b/docs/Черновики/Черновик_дополнений_каналов_и_типов_сообщений_SHiNE.md index ca008a28..55b0bcc2 100644 --- a/docs/Черновики/Черновик_дополнений_каналов_и_типов_сообщений_SHiNE.md +++ b/docs/Черновики/Черновик_дополнений_каналов_и_типов_сообщений_SHiNE.md @@ -55,7 +55,7 @@ - `type=1` — `TEXT` - `type=2` — `REACTION` - `type=3` — `CONNECTION` -- `type=4` — `USER_PARAM` +- `type=4` — `USER_PROFILE` ## Верхнеуровневые типы первой итерации @@ -65,7 +65,7 @@ - `1` — `TEXT` - `2` — `REACTION` - `3` — `CONNECTION` -- `4` — `USER_PARAM` +- `4` — `USER_PROFILE` - `5` — `STATUS_ACTION` Отдельно: @@ -652,7 +652,7 @@ | 1 | TEXT | старый код, новое расширенное смысловое описание | | 2 | REACTION | старый | | 3 | CONNECTION | старый | -| 4 | USER_PARAM | старый | +| 4 | USER_PROFILE | старый | | 5 | STATUS_ACTION | первая итерация | | 6 | CHANNEL_MEMBERSHIP | вынесено в отдельный отложенный черновик | diff --git a/shine-UI/img/pwa-icon-192.png b/shine-UI/img/pwa-icon-192.png new file mode 100644 index 00000000..c0dc2d37 Binary files /dev/null and b/shine-UI/img/pwa-icon-192.png differ diff --git a/shine-UI/img/pwa-icon-512.png b/shine-UI/img/pwa-icon-512.png new file mode 100644 index 00000000..9bea9771 Binary files /dev/null and b/shine-UI/img/pwa-icon-512.png differ diff --git a/shine-UI/img/pwa-icon-maskable-512.png b/shine-UI/img/pwa-icon-maskable-512.png new file mode 100644 index 00000000..07e0cbae Binary files /dev/null and b/shine-UI/img/pwa-icon-maskable-512.png differ diff --git a/shine-UI/index.html b/shine-UI/index.html index 3430e76f..ad0b1b8d 100644 --- a/shine-UI/index.html +++ b/shine-UI/index.html @@ -6,7 +6,7 @@ name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover, interactive-widget=resizes-visual" /> - + @@ -39,13 +39,13 @@ }()); + + diff --git a/shine-UI/static-sites/arweave-viewer/README.md b/shine-UI/static-sites/arweave-viewer/README.md index 5f306626..3e17ca94 100644 --- a/shine-UI/static-sites/arweave-viewer/README.md +++ b/shine-UI/static-sites/arweave-viewer/README.md @@ -25,16 +25,16 @@ index.html?key=&channel=books &solanaRpc=https://api.mainnet-beta.solana.com ``` -`channel` можно не передавать. Тогда viewer ищет все DataItem пользователя с `App=test5590` и строит список каналов из найденных блоков. +`channel` можно не передавать. Тогда viewer ищет все DataItem пользователя с `App=test5591` и строит список каналов из найденных блоков. ## Что делает viewer 1. Если передан `login`, вычисляет PDA `user_login=` программы `SHiNEPr1APdAgNBteUyBXcNovaHctpSjUu8oH2ZJdN6` и читает `blockchainKey`. 2. Если передан `key`, использует его напрямую и не обращается к Solana. 3. Из Ed25519/Solana public key вычисляет Arweave owner address как `base64url(SHA-256(pubkey32))`. -4. Делает Arweave GraphQL запрос по owner + `App=test5590`; `channel` применяется локально после загрузки авторского блокчейна. +4. Делает Arweave GraphQL запрос по owner + `App=test5591`; `channel` применяется локально после загрузки авторского блокчейна. 5. Загружает payload каждого DataItem через gateway `/`. -6. Разбирает payload как SHiNE Frame v1 (`frameCode=0x0001`, header 56 bytes). +6. Разбирает payload как SHiNE Frame v1 (`frameCode=0x0001`, header 88 bytes). 7. Дедуплицирует повторно опубликованные одинаковые пользовательские блоки по SHA-256 Frame v1. 8. Восстанавливает канал/сообщения тем же body parser, который использовал старый viewer. diff --git a/shine-UI/static-sites/arweave-viewer/history/v1/index.html b/shine-UI/static-sites/arweave-viewer/history/v1/index.html index 72484911..2d5a0a38 100644 --- a/shine-UI/static-sites/arweave-viewer/history/v1/index.html +++ b/shine-UI/static-sites/arweave-viewer/history/v1/index.html @@ -1789,12 +1789,12 @@ var solanaWeb3=function(exports){"use strict";function getDefaultExportFromCjs(x function updateSummary(data) { if (!data) { - summaryFields.login.textContent = '—'; - summaryFields.pda.textContent = '—'; - summaryFields.recordNumber.textContent = '—'; - summaryFields.blockchainName.textContent = '—'; - summaryFields.arweave.textContent = '—'; - summaryFields.lastBlock.textContent = '—'; + summaryFields.login.textContent = '–'; + summaryFields.pda.textContent = '–'; + summaryFields.recordNumber.textContent = '–'; + summaryFields.blockchainName.textContent = '–'; + summaryFields.arweave.textContent = '–'; + summaryFields.lastBlock.textContent = '–'; setLinkState(solanaAccountLink, '', 'Открыть PDA в Solana explorer'); setLinkState(arweaveLink, '', 'Открыть Arweave запись'); return; @@ -2297,27 +2297,27 @@ var solanaWeb3=function(exports){"use strict";function getDefaultExportFromCjs(x
Логин - — + –
PDA - — + –
Версия записи - — + –
Блокчейн - — + –
Arweave TX - — + –
Последний блок - — + –
diff --git a/shine-UI/static-sites/arweave-viewer/index.html b/shine-UI/static-sites/arweave-viewer/index.html index f56cd783..41074cba 100644 --- a/shine-UI/static-sites/arweave-viewer/index.html +++ b/shine-UI/static-sites/arweave-viewer/index.html @@ -1097,9 +1097,12 @@ var solanaWeb3=function(exports){"use strict";function getDefaultExportFromCjs(x const BLOCK_TYPE_SESSIONS = 50; const BLOCK_TYPE_TRUSTED_STATE = 70; const BLOCK_TYPE_ARCHIVE_HEAD = 80; - const BCH_FRAME_HEADER_SIZE = 56; + const BCH_FRAME_HEADER_SIZE = 88; const BCH_FRAME_CODE_V1 = 0x0001; - const SHINE_ARWEAVE_APP_TAG = 'test5590'; + // Transport namespace актуального standalone Viewer. + const SHINE_PROTOCOL_NAMESPACE = 'test5591'; + const SHINE_ARWEAVE_APP_TAG = SHINE_PROTOCOL_NAMESPACE; + const SHINE_ARWEAVE_CHANNEL_TAG = 'c'; const BCH_TYPE_TECH = 0; const BCH_TYPE_TEXT = 1; const BCH_SUBTYPE_HEADER = 0; @@ -2058,22 +2061,23 @@ var solanaWeb3=function(exports){"use strict";function getDefaultExportFromCjs(x if (frameCode !== BCH_FRAME_CODE_V1) { throw new Error(`Неожиданный frameCode 0x${frameCode.toString(16)} (ожидался 0x0001)`); } - const blockSize = readInt32BE(bytes, 34); + const blockSize = readInt32BE(bytes, 66); if (blockSize !== bytes.length || blockSize < BCH_FRAME_HEADER_SIZE) { throw new Error(`Frame size mismatch: blockSize=${blockSize}, actual=${bytes.length}`); } const hashBytes = await digestSha256(bytes); - const type = readUint16BE(bytes, 50); - const subType = readUint16BE(bytes, 52); - const version = readUint16BE(bytes, 54); + const type = readUint16BE(bytes, 82); + const subType = readUint16BE(bytes, 84); + const version = readUint16BE(bytes, 86); const bodyBytes = bytes.slice(BCH_FRAME_HEADER_SIZE); const body = parseBlockchainBody(type, subType, version, bodyBytes); return { frameCode, prevHashHex: bytesToHex(bytes.slice(2, 34)), + back32HashHex: bytesToHex(bytes.slice(34, 66)), blockSize, - blockNumber: readInt32BE(bytes, 38), - timestampSec: readInt64BE(bytes, 42), + blockNumber: readInt32BE(bytes, 70), + timestampSec: readInt64BE(bytes, 74), type, subType, version, @@ -2501,7 +2505,7 @@ var solanaWeb3=function(exports){"use strict";function getDefaultExportFromCjs(x let offset = 0; while (offset < data.length) { if (data.length - offset < BCH_FRAME_HEADER_SIZE) throw new Error(`Frame обрывается на смещении ${offset}`); - const blockSize = readInt32BE(data, offset + 34); + const blockSize = readInt32BE(data, offset + 66); if (blockSize < BCH_FRAME_HEADER_SIZE || offset + blockSize > data.length) throw new Error(`Некорректный blockSize ${blockSize} на смещении ${offset}`); blocks.push(await parseBlockchainBlock(data.slice(offset, offset + blockSize))); offset += blockSize; @@ -2660,12 +2664,12 @@ var solanaWeb3=function(exports){"use strict";function getDefaultExportFromCjs(x function updateSummary(data) { if (!data) { - summaryFields.login.textContent = '—'; - summaryFields.pda.textContent = '—'; - summaryFields.recordNumber.textContent = '—'; - summaryFields.blockchainName.textContent = '—'; - summaryFields.arweave.textContent = '—'; - summaryFields.lastBlock.textContent = '—'; + summaryFields.login.textContent = '–'; + summaryFields.pda.textContent = '–'; + summaryFields.recordNumber.textContent = '–'; + summaryFields.blockchainName.textContent = '–'; + summaryFields.arweave.textContent = '–'; + summaryFields.lastBlock.textContent = '–'; setLinkState(solanaAccountLink, '', 'Открыть PDA в Solana explorer'); setLinkState(arweaveLink, '', 'Открыть Arweave запись'); updateToolbarState(); @@ -3309,7 +3313,7 @@ var solanaWeb3=function(exports){"use strict";function getDefaultExportFromCjs(x clearBlockchainBrowser(); setContentStatus('ok', 'Viewer читает новый формат Arweave: ?login=...&channel=... или ?key=...&channel=...'); renderResult({ - info: 'Передайте ?login=...&channel=... — ключ будет взят из Solana PDA. Или ?key=&channel=... — прямое чтение Arweave без Solana.', + info: 'Передайте ?login=...&channel=... – ключ будет взят из Solana PDA. Или ?key=&channel=... – прямое чтение Arweave без Solana.', }); showEmptyState('Укажите логин пользователя SHiNE и откройте его блокчейн.'); updateToolbarState(); @@ -3345,7 +3349,7 @@ var solanaWeb3=function(exports){"use strict";function getDefaultExportFromCjs(x const oldSetContentStatus = setContentStatus; setContentStatus = function(kind,text){ oldSetContentStatus(kind,text); const el=document.getElementById('v3-status'); if(el) el.textContent=text; v3Log(text); }; function v3Theme(theme){ document.documentElement.dataset.theme=theme; localStorage.setItem('shine.viewer.theme',theme); const b=document.getElementById('v3-theme'); if(b)b.textContent=theme==='dark'?'☀':'☾'; } - function v3RenderBlocks(){ const host=document.getElementById('v3-block-view'); if(!host)return; host.innerHTML=''; const wrap=document.createElement('div'); wrap.className='v3-blocks'; const blocks=(currentBlockchainView?.rawBlocks||V3.blocks||[]).slice().sort((a,b)=>b.blockNumber-a.blockNumber); blocks.forEach(b=>{ const d=document.createElement('details'); d.className='v3-block'; const sm=document.createElement('summary'); sm.textContent=`#${b.blockNumber} · type ${b.type}/${b.subType} · ${formatTimestamp(Number(b.timestampSec)*1000)}`; const pre=document.createElement('pre'); pre.textContent=JSON.stringify({blockNumber:b.blockNumber,type:b.type,subType:b.subType,version:b.version,hash:b.hashHex,prevHash:b.prevHashHex,arweaveId:b.arweaveId,body:b.body},(k,v)=>typeof v==='bigint'?String(v):v,2); d.append(sm,pre); wrap.appendChild(d); }); if(!blocks.length)wrap.textContent='Блоки ещё не загружены.'; host.appendChild(wrap); } + function v3RenderBlocks(){ const host=document.getElementById('v3-block-view'); if(!host)return; host.innerHTML=''; const wrap=document.createElement('div'); wrap.className='v3-blocks'; const blocks=(currentBlockchainView?.rawBlocks||V3.blocks||[]).slice().sort((a,b)=>b.blockNumber-a.blockNumber); blocks.forEach(b=>{ const d=document.createElement('details'); d.className='v3-block'; const sm=document.createElement('summary'); sm.textContent=`#${b.blockNumber} · type ${b.type}/${b.subType} · ${formatTimestamp(Number(b.timestampSec)*1000)}`; const pre=document.createElement('pre'); pre.textContent=JSON.stringify({blockNumber:b.blockNumber,type:b.type,subType:b.subType,version:b.version,hash:b.hashHex,prevHash:b.prevHashHex,back32Hash:b.back32HashHex,arweaveId:b.arweaveId,body:b.body},(k,v)=>typeof v==='bigint'?String(v):v,2); d.append(sm,pre); wrap.appendChild(d); }); if(!blocks.length)wrap.textContent='Блоки ещё не загружены.'; host.appendChild(wrap); } function v3SetView(mode){ const bv=document.getElementById('v3-block-view'), cb=document.getElementById('content-browser'); document.getElementById('v3-channel-tab').classList.toggle('is-active',mode==='channel'); document.getElementById('v3-blocks-tab').classList.toggle('is-active',mode==='blocks'); if(bv)bv.hidden=mode!=='blocks'; if(cb)cb.hidden=mode==='blocks'; if(mode==='blocks')v3RenderBlocks(); } async function v3ClearCache(){ try{ const keys=Object.keys(localStorage).filter(k=>k.startsWith('shine.viewer.data.')); keys.forEach(k=>localStorage.removeItem(k)); if('caches' in window){ for(const k of await caches.keys()) if(k.startsWith('shine-viewer-')) await caches.delete(k); } v3Log('Кэш данных очищен'); }catch(e){v3Log('Ошибка очистки кэша: '+e.message);} } function v3CacheKey(key,channel){return 'shine.viewer.author-chain.'+String(key);} @@ -3372,7 +3376,7 @@ var solanaWeb3=function(exports){"use strict";function getDefaultExportFromCjs(x function v3Verification(blocks){ blocks=(blocks||[]).slice().sort((a,b)=>a.blockNumber-b.blockNumber); const byNum=new Map(blocks.map(b=>[Number(b.blockNumber),b])); - const result={total:blocks.length,frameHash:{ok:blocks.length,bad:0,na:0},global:{ok:0,bad:0,na:0},channel:{ok:0,bad:0,na:0},owner:{ok:0,bad:0,na:0},signature:{ok:0,bad:0,na:blocks.length},issues:[]}; + const result={total:blocks.length,frameHash:{ok:blocks.length,bad:0,na:0},global:{ok:0,bad:0,na:0},back32:{ok:0,bad:0,na:0},channel:{ok:0,bad:0,na:0},owner:{ok:0,bad:0,na:0},signature:{ok:0,bad:0,na:blocks.length},issues:[]}; for(const b of blocks){ // hashHex is SHA-256(Frame) calculated locally by parseBlockchainBlock. if(!b.hashHex){result.frameHash.ok--;result.frameHash.na++;} @@ -3384,6 +3388,16 @@ var solanaWeb3=function(exports){"use strict";function getDefaultExportFromCjs(x else if(String(prev.hashHex).toLowerCase()===String(b.prevHashHex).toLowerCase()) result.global.ok++; else{result.global.bad++;result.issues.push({kind:'global',state:'bad',block:b.blockNumber,text:`prevHash не совпадает с SHA-256 блока #${prev.blockNumber}`});} } + const back32=String(b.back32HashHex||''); + if(Number(b.blockNumber)<32){ + if(v3ZeroHash(back32)) result.back32.ok++; + else{result.back32.bad++;result.issues.push({kind:'back32',state:'bad',block:b.blockNumber,text:'Для блока <32 back32Hash должен быть нулевым'});} + } else { + const target=byNum.get(Number(b.blockNumber)-32); + if(!target){result.back32.na++;result.issues.push({kind:'back32',state:'na',block:b.blockNumber,text:`Нет блока #${Number(b.blockNumber)-32} для проверки back32Hash`});} + else if(String(target.hashHex).toLowerCase()===back32.toLowerCase()) result.back32.ok++; + else{result.back32.bad++;result.issues.push({kind:'back32',state:'bad',block:b.blockNumber,text:`back32Hash не совпадает с SHA-256 блока #${Number(b.blockNumber)-32}`});} + } const body=b.body||{}; if(body.kind==='text_line' || body.kind==='create_channel'){ const pn=Number(body.prevLineNumber||0), ph=String(body.prevLineHashHex||''); @@ -3402,8 +3416,8 @@ var solanaWeb3=function(exports){"use strict";function getDefaultExportFromCjs(x function v3UpdateVerification(){ const r=v3Verification(currentBlockchainView?.rawBlocks||V3.blocks||[]); V3.verification=r; - const bad=r.global.bad+r.channel.bad+r.frameHash.bad+r.owner.bad+r.signature.bad; - const checked=r.global.ok+r.channel.ok; + const bad=r.global.bad+r.back32.bad+r.channel.bad+r.frameHash.bad+r.owner.bad+r.signature.bad; + const checked=r.global.ok+r.back32.ok+r.channel.ok; const el=document.getElementById('v3-status'); if(el && r.total) el.textContent=`${bad?'⚠':'✓'} Хэши ${checked} · global ${v3MetricText(r.global)} · канал ${v3MetricText(r.channel)} · owner ${v3MetricText(r.owner)}`; return r; @@ -3416,6 +3430,7 @@ var solanaWeb3=function(exports){"use strict";function getDefaultExportFromCjs(x document.getElementById('v3-verify-summary').innerHTML= v3VerifyCard('SHA-256 Frame',r.frameHash,'вычислен локально')+ v3VerifyCard('Общая цепочка',r.global,'prevHash')+ + v3VerifyCard('Резерв N−32',r.back32,'back32Hash')+ v3VerifyCard('Цепочки каналов',r.channel,'prevLineHash')+ v3VerifyCard('Arweave owner',r.owner,'совпадение выборки owner'); const sig=document.getElementById('v3-signature-note'); diff --git a/shine-UI/static-sites/breath-belly-sensor/1/index.html b/shine-UI/static-sites/breath-belly-sensor/1/index.html new file mode 100644 index 00000000..cdafe110 --- /dev/null +++ b/shine-UI/static-sites/breath-belly-sensor/1/index.html @@ -0,0 +1,725 @@ + + + + + + + Дыхание по движению живота + + + +
+
+

Дыхание

+

Положите телефон экраном вверх на живот и лежите спокойно. Приложение использует датчики движения телефона, чтобы оценивать ритм дыхания.

+
+ +
+
+
+
+
Сейчас
+
Готово
+
+
+ — + качество сигнала +
+
+
+
Нажмите «Начать». Первые 10 секунд — калибровка.
+ +
+ + +
+
+ + + +
+
+ +
+
+
За последнюю 1 минуту
+
—
+
сек/цикл · — дых./мин
+
+
+
За последние 3 минуты
+
—
+
сек/цикл · — дых./мин
+
+
+
За последние 5 минут
+
—
+
сек/цикл · — дых./мин
+
+
+
+ +
+
+

Сигнал движения

+ датчик ещё не запущен +
+ +
+ +
+
+

Вдохи и выдохи

+ 0 циклов +
+
+ + + + + + + + + + + + + +
ВремяВдохВыдохЦиклТемп
Пока нет завершённых циклов
+
+
+ +
+ Диагностика датчика +
—
+
+

Это экспериментальная оценка ритма дыхания по движению телефона, а не медицинский измерительный прибор. Для наиболее стабильного результата телефон должен лежать свободно и не скользить по одежде.

+
+ + + + diff --git a/shine-UI/static-sites/breath-belly-sensor/index.html b/shine-UI/static-sites/breath-belly-sensor/index.html new file mode 100644 index 00000000..bf6a0126 --- /dev/null +++ b/shine-UI/static-sites/breath-belly-sensor/index.html @@ -0,0 +1,920 @@ + + + + + + + Дыхание по движению живота + + + +
+
+

Дыхание

+

Положите телефон экраном вверх на живот и лежите спокойно. Приложение использует датчики движения телефона, чтобы оценивать ритм дыхания.

+
+ +
+
+
+
+
Сейчас
+
Готово
+
+
+ — + качество сигнала +
+
+
+
Нажмите «Начать». Первые 10 секунд — калибровка.
+ +
+ + +
+
+ + + +
+
+ +
+
+
За последнюю 1 минуту
+
+
Вдох—
+
Выдох—
+
Цикл—
+
+
— дых./мин
+
+
+
За последние 3 минуты
+
+
Вдох—
+
Выдох—
+
Цикл—
+
+
— дых./мин
+
+
+
За последние 5 минут
+
+
Вдох—
+
Выдох—
+
Цикл—
+
+
— дых./мин
+
+
+
+ +
+
+

Контроль темпа

+ порог проверяется после каждого полного цикла +
+
+
+
+
Звуковые предупреждения
+
Если средний цикл за последнюю минуту короче порога: 1 сигнал, затем 2, 3 и т.д.
+
+ +
+
+
+
Минимальный средний цикл
+
Полный цикл = вдох + выдох. Диапазон 5–15 секунд.
+ +
+
+
10 c
+
порог
+
+
+
+
+
+
Предупреждение
+
Пока недостаточно данных.
+
+
0
+
+
+ +
+
+

Сигнал движения

+ датчик ещё не запущен +
+ +
+ +
+
+

Вдохи и выдохи

+ 0 циклов +
+
+ + + + + + + + + + + + + +
ВремяВдохВыдохЦиклТемп
Пока нет завершённых циклов
+
+
+ +
+ Диагностика датчика +
—
+
+

Это экспериментальная оценка ритма дыхания по движению телефона, а не медицинский измерительный прибор. Для наиболее стабильного результата телефон должен лежать свободно и не скользить по одежде.

+
+ + + + diff --git a/shine-UI/static-sites/design-examples/channels-v1/index.html b/shine-UI/static-sites/design-examples/channels-v1/index.html index f74d5db0..88806e33 100644 --- a/shine-UI/static-sites/design-examples/channels-v1/index.html +++ b/shine-UI/static-sites/design-examples/channels-v1/index.html @@ -3,19 +3,19 @@ - SHiNE — четыре направления UI + SHiNE – четыре направления UI
- ✳ SHiNEDESIGN STUDY / 01 + ✳ SHiNEDESIGN STUDY / 01 Концепции · сентябрь 2026
-
КАНАЛЫ / СООБЩЕНИЯ / ОТВЕТЫ

Ближе к разговору.

Четыре характера. Один привычный путь от канала к ответу.
Выберите экран и сравните — или нажмите на элементы внутри макета.

-
01—04

Меньше визуального шума.
Больше места людям и мыслям.

+
КАНАЛЫ / СООБЩЕНИЯ / ОТВЕТЫ

Ближе к разговору.

Четыре характера. Один привычный путь от канала к ответу.
Выберите экран и сравните – или нажмите на элементы внутри макета.

+
01–04

Меньше визуального шума.
Больше места людям и мыслям.

diff --git a/shine-UI/static-sites/design-examples/channels-v1/mockups.js b/shine-UI/static-sites/design-examples/channels-v1/mockups.js index 8c97645d..1d97db81 100644 --- a/shine-UI/static-sites/design-examples/channels-v1/mockups.js +++ b/shine-UI/static-sites/design-examples/channels-v1/mockups.js @@ -43,7 +43,7 @@ const channels = [ let role = 'reader'; let showKeyboard = false; const states = new Map(); -const mainText = 'Иногда лучший маршрут — чуть длиннее обычного. Сегодня свернула к реке и нашла это место. А где вы перезагружаетесь после рабочего дня?'; +const mainText = 'Иногда лучший маршрут – чуть длиннее обычного. Сегодня свернула к реке и нашла это место. А где вы перезагружаетесь после рабочего дня?'; const secondText = 'Собрала наши любимые места в один список. Добавляйте свои находки в ответах!'; const landscape = () => ``; function header(s) { @@ -198,8 +198,8 @@ function handle(s, event) { else if (action==='details') menu(s,'Данные записи','

Здесь доступны номер записи, цепочка автора, хэш и подпись. В мокапе технические данные не генерируются.

',el); else if (action==='about') menu(s,'О канале','

Замечаем красоту рядом. Делимся местами, историями и маленькими открытиями.

Автор: @'+escapeText(s.channel.owner)+'

',el); else if (action==='close-menu') { removeOverlay(s); if(s.returnFocus?.isConnected)s.returnFocus.focus({preventScroll:true}); } - else if (action==='new-channel') toast(s,'Создание канала — следующий этап проектирования'); - else if (action==='edit-demo') toast(s,'Редактор существующего сообщения — следующий этап'); + else if (action==='new-channel') toast(s,'Создание канала – следующий этап проектирования'); + else if (action==='edit-demo') toast(s,'Редактор существующего сообщения – следующий этап'); else if (action==='outside') toast(s,'Сейчас проектируем каналы. Этот раздел пока вне макета.'); } function attachEvents(s) { diff --git a/shine-UI/styles/app-shell.css b/shine-UI/styles/app-shell.css index 99be0bb5..fd4a2945 100644 --- a/shine-UI/styles/app-shell.css +++ b/shine-UI/styles/app-shell.css @@ -49,7 +49,7 @@ } .app-shell.has-minimized-call .screen-content { - padding-top: 12px; + padding-top: var(--page-top-gap); } .topbar-slot, @@ -131,7 +131,7 @@ /* Обычный scroll-container физически продолжается под прозрачным TopBar. */ .app-shell--content-under-topbar:not(.app-shell--scroll-nested):not(.app-shell--scroll-locked) .screen-content:not(.no-app-chrome) { top: var(--call-minimized-bar-height, 0px); - padding-top: calc(var(--topbar-height, 64px) + 14px); + padding-top: calc(var(--topbar-height, 64px) + var(--page-top-gap)); } /* Вложенный scroll-container (например, переписка) сам резервирует место под chrome. */ diff --git a/shine-UI/styles/buttons-white.css b/shine-UI/styles/buttons-white.css index 47b5dc38..e8cd78c9 100644 --- a/shine-UI/styles/buttons-white.css +++ b/shine-UI/styles/buttons-white.css @@ -1,7 +1,8 @@ /* Семантические роли кнопок. Геометрией сложных компонентов владеют их стили. */ .ui-button, .primary-btn, .secondary-btn, .destructive-btn, .ghost-btn, .icon-btn, .text-btn, .shine-btn { color: var(--text-primary); background: transparent; border: 0; box-shadow: none; font: inherit; cursor: pointer; transition: background-color 160ms ease, color 160ms ease; } .primary-btn { color: var(--on-accent); background: var(--accent); } -.secondary-btn { color: var(--text-primary); background: var(--surface); border: 1px solid var(--border-control); } +/* Второстепенное действие: прозрачная, тонкая рамка, текст цвета «вторичного действия». */ +.secondary-btn { color: var(--action); background: transparent; border: 1px solid var(--border-control); } .destructive-btn { color: var(--danger); } :is(.ui-button, .primary-btn, .secondary-btn, .destructive-btn, .ghost-btn, .icon-btn, .text-btn, .shine-btn):hover { filter: brightness(.96); } :is(.ui-button, .primary-btn, .secondary-btn, .destructive-btn, .ghost-btn, .icon-btn, .text-btn, .shine-btn):active { filter: brightness(.9); } @@ -16,9 +17,9 @@ text-shadow: none; } -.filled-action-buttons :is(.secondary-btn, .ghost-btn, .text-btn, .login-panel-inline-back, .profiles-close) { - color: var(--text-primary); - background: var(--surface); +.filled-action-buttons :is(.secondary-btn, .ghost-btn, .text-btn, .profiles-close) { + color: var(--action); + background: transparent; border: 1px solid var(--border-control); border-radius: var(--radius-md); box-shadow: none; @@ -27,23 +28,23 @@ .filled-action-buttons .destructive-btn { color: var(--danger); - background: var(--surface); + background: transparent; border: 1px solid var(--border-control); border-radius: var(--radius-md); } -.filled-action-buttons :is(.primary-btn, .secondary-btn, .destructive-btn, .ghost-btn, .text-btn, .shine-btn, .square-btn, .login-panel-inline-back, .registration-faq-link, .profiles-select, .profiles-close):active { +.filled-action-buttons :is(.primary-btn, .secondary-btn, .destructive-btn, .ghost-btn, .text-btn, .shine-btn, .square-btn, .registration-faq-link, .profiles-select, .profiles-close):active { transform: scale(0.98); } -.filled-action-buttons :is(.primary-btn, .secondary-btn, .destructive-btn, .ghost-btn, .text-btn, .shine-btn, .square-btn, .login-panel-inline-back, .registration-faq-link, .profiles-select, .profiles-close):disabled { +.filled-action-buttons :is(.primary-btn, .secondary-btn, .destructive-btn, .ghost-btn, .text-btn, .shine-btn, .square-btn, .registration-faq-link, .profiles-select, .profiles-close):disabled { color: var(--text-secondary); background: var(--surface-selected); border-color: transparent; } -.filled-action-buttons :is(.primary-btn, .secondary-btn, .destructive-btn, .ghost-btn, .text-btn, .shine-btn, .square-btn, .login-panel-inline-back, .registration-faq-link, .profiles-select, .profiles-close)::before, -.filled-action-buttons :is(.primary-btn, .secondary-btn, .destructive-btn, .ghost-btn, .text-btn, .shine-btn, .square-btn, .login-panel-inline-back, .registration-faq-link, .profiles-select, .profiles-close)::after { +.filled-action-buttons :is(.primary-btn, .secondary-btn, .destructive-btn, .ghost-btn, .text-btn, .shine-btn, .square-btn, .registration-faq-link, .profiles-select, .profiles-close)::before, +.filled-action-buttons :is(.primary-btn, .secondary-btn, .destructive-btn, .ghost-btn, .text-btn, .shine-btn, .square-btn, .registration-faq-link, .profiles-select, .profiles-close)::after { content: none; } diff --git a/shine-UI/styles/components/attachments.css b/shine-UI/styles/components/attachments.css index debfd7e7..4f4b88dd 100644 --- a/shine-UI/styles/components/attachments.css +++ b/shine-UI/styles/components/attachments.css @@ -137,44 +137,6 @@ } -.message-attachment-download { - display: inline-flex; - align-items: center; - min-height: 44px; - background: var(--accent); - border-radius: 999px; - color: var(--on-accent); - font-size: 0.82rem; - font-weight: 700; - padding: 0.45rem 0.75rem; - position: relative; - text-decoration: none; - width: max-content; - z-index: 3; -} - - -.message-attachment-media-frame > .message-attachment-download { - bottom: 0.5rem; - position: absolute; - right: 0.5rem; -} - -.message-attachment-download--icon { - width: 36px; - min-height: 36px; - height: 36px; - padding: 0; - justify-content: center; - border-radius: 50%; - color: #fff; - background: rgba(0, 0, 0, 0.45); - backdrop-filter: blur(6px); - -webkit-backdrop-filter: blur(6px); -} -.message-attachment-download--icon svg { width: 18px; height: 18px; } -.message-attachment-download--icon:hover { background: rgba(0, 0, 0, 0.6); } - .message-attachment-media-frame:not(.is-loaded) { background: var(--surface-selected); animation: attachment-loading 1.2s ease-in-out infinite alternate; } .message-attachment-media-frame.is-loaded { background: transparent; } @keyframes attachment-loading { from { opacity: 1; } to { opacity: .55; } } @@ -228,6 +190,7 @@ background: var(--surface); color: var(--danger); display: flex; + flex-direction: column; font-weight: 700; justify-content: center; min-height: 12rem; @@ -235,6 +198,22 @@ text-align: center; } +.message-attachment-debug { + width: 100%; + margin: 10px 0 0; + padding: 8px; + overflow-x: auto; + white-space: pre-wrap; + word-break: break-all; + border: 1px solid var(--border-subtle); + border-radius: 8px; + color: var(--text-secondary); + font-size: 11px; + font-weight: 500; + line-height: 1.35; + text-align: left; +} + .message-attachment-card { align-items: center; @@ -299,84 +278,32 @@ .message-attachment-file-card { grid-template-columns: auto minmax(0, 1fr); } -.message-attachment-file-card .message-attachment-download { - grid-column: 1 / -1; - } } .ar-attachment-manager-root .modal { z-index: 120; } -.attachment-viewer-modal { - z-index: 80; -} - - -.attachment-viewer-card { - background: var(--surface); - border: 1px solid var(--border-subtle); - border-radius: 1.2rem; - box-shadow: none; - color: var(--text-primary); - display: grid; - gap: 0.8rem; - max-height: 92vh; - max-width: min(94vw, 68rem); - padding: 0.9rem; - width: 100%; -} - - -.attachment-viewer-head, -.attachment-viewer-actions { - align-items: center; - display: flex; - gap: 0.8rem; - justify-content: space-between; -} - - -.attachment-viewer-title { - font-weight: 800; - min-width: 0; - overflow: hidden; - text-overflow: ellipsis; - white-space: nowrap; -} - - -.attachment-viewer-body { - align-items: center; - display: grid; - justify-items: center; - min-height: 12rem; -} - - -.attachment-viewer-media { - background: var(--background); - border-radius: 0.8rem; - max-height: 76vh; - max-width: 100%; - object-fit: contain; -} - - .ar-attachment-manager-card { max-width: min(92vw, 34rem); - gap: 16px; + gap: var(--space-3); } -.ar-attachment-manager-head { display: flex; align-items: center; justify-content: space-between; gap: 8px; } -.ar-attachment-manager-close { width: 44px; min-width: 44px; padding: 0; font-size: 18px; color: var(--text-secondary); } -.ar-attachment-note { margin: 0; font-size: .8125rem; line-height: 1.25rem; color: var(--text-secondary); } -.ar-attachment-alt-sources { display: flex; flex-wrap: wrap; gap: 4px 16px; } -.ar-attachment-link { min-height: 44px; padding: 0; justify-self: start; color: var(--accent); background: transparent; font-weight: 500; } +/* Пустые служебные блоки (сумма, превью, ошибка) не должны давать промежутков. */ +.ar-attachment-manager-card :is(.ar-attachment-meta, .inline-error):empty, +.ar-attachment-manager-card [hidden] { display: none; } +.ar-attachment-manager-head { display: flex; align-items: center; justify-content: space-between; gap: 8px; } +.ar-attachment-manager-close { display: grid; place-items: center; width: 44px; min-width: 44px; padding: 0; color: var(--text-secondary); } +.ar-attachment-manager-close svg { width: 20px; height: 20px; } +.ar-attachment-note { margin: 0; font-size: .8125rem; line-height: 1.25rem; color: var(--text-secondary); } +.ar-attachment-alt-sources { display: flex; flex-wrap: wrap; gap: 0 var(--space-4); } +.ar-attachment-link { min-height: 36px; padding: 0; justify-self: start; color: var(--action); background: transparent; font-size: var(--text-sm); font-weight: var(--weight-medium); } + +/* Та же высота, что у поля ввода (44), кнопка внутри – как в переключателе (34). */ .ar-attachment-file-picker { - min-height: 56px; - padding: 8px; + min-height: var(--control-height); + padding: 4px; display: flex; align-items: center; - gap: 12px; + gap: var(--space-3); border: 1px dashed var(--border-control); border-radius: 12px; background: var(--surface); @@ -387,11 +314,12 @@ .ar-attachment-file-input { position: absolute; width: 1px; height: 1px; opacity: 0; pointer-events: none; } .ar-attachment-file-btn { flex-shrink: 0; - min-height: 40px; + min-height: 34px; padding: 0 14px; display: inline-flex; align-items: center; - border-radius: 10px; + border-radius: 8px; + font-size: var(--text-md); color: var(--on-accent); background: var(--accent); font-weight: 600; @@ -519,45 +447,6 @@ } -.ar-attachment-history-tile--with-preview { - gap: 0.32rem; - padding: 0.42rem; -} - - -.ar-attachment-history-preview { - align-items: flex-end; - background: var(--border-subtle); - border-radius: 0.42rem; - display: flex; - justify-content: space-between; - min-height: 7rem; - overflow: hidden; - position: relative; -} - - -.ar-attachment-history-preview-image { - display: block; - height: 100%; - object-fit: cover; - width: 100%; -} - - -.ar-attachment-history-preview-badge { - background: var(--surface); - border: 1px solid var(--border-subtle); - border-radius: 999px; - bottom: 0.42rem; - color: var(--text-primary); - font-size: 0.6875rem; - left: 0.42rem; - padding: 0.2rem 0.46rem; - position: absolute; -} - - .ar-attachment-history-tile-head { align-items: flex-start; display: flex; @@ -650,3 +539,118 @@ line-height: 1; padding: 0.2rem 0.32rem; } + +/* ===== Public / Arweave attachment source picker ===== */ +.public-attachment-manager-root { + position: fixed; + inset: 0; + z-index: 1200; +} + +.public-attachment-manager { + position: fixed; + inset: 0; + display: grid; + place-items: center; + padding: 20px; + background: var(--scrim); +} + +.public-attachment-manager__card { + width: min(620px, 100%); + max-height: min(820px, calc(100dvh - 40px)); + overflow: auto; +} + +.public-attachment-manager__header { + display: flex; + align-items: center; + justify-content: space-between; + gap: 12px; +} + +.public-attachment-manager__sources { + display: grid; + grid-template-columns: repeat(2, minmax(0, 1fr)); + gap: 10px; +} + +.public-attachment-manager__source { + display: flex; + align-items: flex-start; + gap: 10px; + padding: 14px; + border: 1px solid var(--border-control); + border-radius: var(--radius-md); + background: var(--surface); + cursor: pointer; +} + +.public-attachment-manager__source.is-selected { + border-color: var(--accent); + background: var(--accent-soft); +} + +.public-attachment-manager__source input { margin-top: 3px; } +.public-attachment-manager__source span { display: grid; gap: 3px; } +.public-attachment-manager__source small { color: var(--text-secondary); line-height: 1.35; } + +.public-attachment-manager__server, +.public-attachment-manager__arweave { + display: grid; + gap: 12px; +} + +/* The two storage modes are mutually exclusive. Keep this explicit because + the author-level display:grid above otherwise overrides the browser's + default [hidden] rule in some engines. */ +.public-attachment-manager__server[hidden], +.public-attachment-manager__arweave[hidden] { + display: none; +} + +.public-attachment-manager__notice { + display: grid; + gap: 8px; + padding: 14px; + border: 1px solid var(--border-subtle); + border-radius: var(--radius-md); + background: var(--quote-bg); + color: var(--text-secondary); + font-size: var(--text-sm); + line-height: var(--leading-sm); +} + +.public-attachment-manager__notice strong { color: var(--text-primary); } +.public-attachment-manager__notice p { margin: 0; } +.public-attachment-manager__status { min-height: 1.25rem; } +.public-attachment-manager__error { min-height: 1.25rem; } + +@media (max-width: 640px) { + .public-attachment-manager { padding: 10px; place-items: end center; } + .public-attachment-manager__card { width: 100%; max-height: calc(100dvh - 20px); } + .public-attachment-manager__sources { grid-template-columns: 1fr; } +} + +/* Unified storage picker / balance dialogs */ +.public-attachment-manager__file-picker { width: 100%; box-sizing: border-box; } +.public-attachment-manager__file-picker .ar-attachment-file-name { flex: 1; text-align: center; } +.ar-balance-modal { z-index: 1400; } +.ar-balance-modal__card { width: min(92vw, 32rem); } +.ar-balance-grid { display: grid; gap: 8px; } +.ar-balance-grid > div { display: flex; justify-content: space-between; gap: 16px; padding: 10px 12px; border: 1px solid var(--border-subtle); border-radius: 10px; } +.ar-balance-grid span { color: var(--text-secondary); } +.ar-wallet-address { padding: 12px; border: 1px solid var(--border-control); border-radius: 10px; background: var(--quote-bg); overflow-wrap: anywhere; user-select: all; } +.ar-attachment-manager-card .form-actions-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); } + +/* Arweave manager embedded inside the unified server / Arweave picker. */ +.ar-attachment-manager-embedded-root { min-width: 0; } +.ar-attachment-manager-card--embedded { + width: 100%; + max-width: none; + margin: 0; + padding: 0; + border: 0; + background: transparent; + box-shadow: none; +} diff --git a/shine-UI/styles/components/avatar.css b/shine-UI/styles/components/avatar.css index d2d04930..053bd698 100644 --- a/shine-UI/styles/components/avatar.css +++ b/shine-UI/styles/components/avatar.css @@ -245,7 +245,7 @@ transform: translate(-50%, -50%); border: 0; border-radius: 0; - background: url("../assets/glass_overlay_faithful.png") center / contain no-repeat; + background: url("../../assets/glass_overlay_faithful.png") center / contain no-repeat; box-shadow: none; opacity: 1; pointer-events: none; diff --git a/shine-UI/styles/components/channel-editor.css b/shine-UI/styles/components/channel-editor.css index 36d90ef1..aee23441 100644 --- a/shine-UI/styles/components/channel-editor.css +++ b/shine-UI/styles/components/channel-editor.css @@ -23,18 +23,20 @@ .channel-editor__header { min-height: calc(56px + env(safe-area-inset-top)); - padding: env(safe-area-inset-top) 6px 0; + padding: env(safe-area-inset-top) 14px 0 6px; display: grid; - grid-template-columns: 44px minmax(0, 1fr) 44px; + grid-template-columns: 44px minmax(0, 1fr) auto; + gap: 6px; align-items: center; border-bottom: 1px solid var(--border-subtle); + background: var(--surface); } .channel-editor__header h2 { font-size: 16px; line-height: 24px; font-weight: 600; - text-align: center; + text-align: left; } .channel-editor__close { @@ -225,3 +227,7 @@ @media (prefers-reduced-motion: reduce) { .channel-editor-overlay, .channel-editor { animation: none; transition: none; } } +.channel-editor__author-text { display: grid; gap: 1px; min-width: 0; } +.channel-editor__author-text small { color: var(--text-secondary); font-size: .75rem; } +.channel-editor__draft { justify-self: end; color: var(--text-secondary); font-size: .75rem; } +.channel-editor__close svg { width: 24px; height: 24px; } diff --git a/shine-UI/styles/components/compose.css b/shine-UI/styles/components/compose.css new file mode 100644 index 00000000..021c0e39 --- /dev/null +++ b/shine-UI/styles/components/compose.css @@ -0,0 +1,14 @@ +/* Строка ввода внизу экрана (обсуждение; тот же рисунок у чата): капсула с полем и эмодзи + круглая отправка */ +.compose-row { display: flex; gap: 6px; align-items: flex-end; } +.compose-field { flex: 1; min-width: 0; display: flex; align-items: flex-end; padding: 0 6px 0 12px; border: 1px solid var(--border-control); border-radius: 22px; background: var(--surface-raised); } +.compose-field:focus-within { border-color: var(--accent); } +.compose-field__input { flex: 1; min-width: 0; min-height: 44px; max-height: 132px; padding: 10px 0; border: 0; background: transparent; color: var(--text-primary); font: inherit; font-size: 1rem; line-height: 1.375rem; resize: none; field-sizing: content; outline: none; } +.compose-field__input::placeholder { color: var(--text-secondary); } +.compose-field__emoji { width: 32px; min-width: 32px; height: 44px; padding: 0; display: grid; place-items: center; border: 0; background: transparent; color: var(--text-secondary); cursor: pointer; } +.compose-field__emoji svg { width: 22px; height: 22px; } +.compose-send { width: 44px; height: 44px; min-width: 44px; padding: 0; display: grid; place-items: center; border: 0; border-radius: 50%; background: var(--accent); color: var(--on-accent); cursor: pointer; } +.compose-send svg { width: 22px; height: 22px; stroke-width: 2.2; } +.compose-send:hover:not(:disabled) { background: var(--accent-hover); } +.compose-send:active:not(:disabled) { background: var(--accent-pressed); } +.compose-send:disabled { background: var(--disabled-bg); color: var(--disabled-text); cursor: default; } +.compose-send:focus-visible, .compose-field__emoji:focus-visible { outline: 2px solid var(--focus-ring); outline-offset: 2px; } diff --git a/shine-UI/styles/components/dropdown-menu.css b/shine-UI/styles/components/dropdown-menu.css index 06c69485..15b105f4 100644 --- a/shine-UI/styles/components/dropdown-menu.css +++ b/shine-UI/styles/components/dropdown-menu.css @@ -1,12 +1,15 @@ :root { --z-overlay: 100; --z-dropdown: 110; --z-modal: 120; } .dropdown-portal { pointer-events: none; } .dropdown-backdrop { position: fixed; inset: 0; z-index: var(--z-overlay); pointer-events: auto; background: var(--scrim); } -.dropdown-menu { position: fixed; z-index: var(--z-dropdown); display: grid; gap: 2px; padding: 6px; min-width: 196px; max-width: calc(100vw - 20px); max-height: calc(100dvh - 20px); overflow-y: auto; border: 1px solid var(--border-subtle); border-radius: 20px; background: var(--surface); color: var(--text-primary); box-shadow: var(--shadow); pointer-events: auto; } -.dropdown-menu__item { width: 100%; min-height: 44px; padding: 10px 12px; display: flex; align-items: center; gap: 10px; border: 0; border-radius: 12px; background: transparent; color: var(--text-primary); font: inherit; font-size: .875rem; line-height: 1.4; text-align: left; cursor: pointer; } -.dropdown-menu__item:hover, .dropdown-menu__item.is-selected { background: var(--surface-selected); } +.dropdown-menu { position: fixed; z-index: var(--z-dropdown); display: grid; gap: 2px; padding: 6px; min-width: 196px; max-width: calc(100vw - 20px); max-height: calc(100dvh - 20px); overflow-y: auto; border: 1px solid var(--border-control); border-radius: 14px; background: var(--surface); color: var(--text-primary); box-shadow: var(--shadow); pointer-events: auto; } +.dropdown-menu__item { width: 100%; min-height: 44px; padding: 8px 10px; display: flex; align-items: center; gap: 10px; border: 0; border-radius: 8px; background: transparent; color: var(--text-primary); font: inherit; font-size: .875rem; line-height: 1.4; text-align: left; cursor: pointer; } +.dropdown-menu__item:hover { background: var(--surface-raised); } +.dropdown-menu__item.is-selected { background: var(--surface-selected); } .dropdown-menu__item:active { background: var(--surface-selected); } .dropdown-menu__item:focus-visible { outline: 2px solid var(--focus-ring); outline-offset: -2px; } .dropdown-menu__item.is-danger { color: var(--danger); } .dropdown-menu__item:disabled { opacity: .5; cursor: not-allowed; } -.dropdown-menu__icon, .dropdown-menu__icon svg, .dropdown-menu__item > img { width: 22px; height: 22px; flex: 0 0 22px; object-fit: contain; color: currentColor; } -.dropdown-menu__divider { height: 1px; margin: 4px 8px; background: var(--border-subtle); } +.dropdown-menu__icon, .dropdown-menu__icon svg, .dropdown-menu__item > img { width: 21px; height: 21px; flex: 0 0 21px; object-fit: contain; } +.dropdown-menu__icon { color: var(--text-secondary); } +.dropdown-menu__item.is-danger .dropdown-menu__icon { color: var(--danger); } +.dropdown-menu__divider { height: 1px; margin: 5px 8px; background: var(--border-subtle); } diff --git a/shine-UI/styles/components/media-viewer.css b/shine-UI/styles/components/media-viewer.css new file mode 100644 index 00000000..2dbf6e15 --- /dev/null +++ b/shine-UI/styles/components/media-viewer.css @@ -0,0 +1,106 @@ +/* Полноэкранный просмотр фото и видео (js/components/media-viewer.js). Чёрный фон в обеих темах – как в галереях. */ +.media-viewer { + --viewer-dim: 1; + position: fixed; + inset: 0; + z-index: 130; + display: grid; + /* Слегка прозрачный фон; размытие не даёт ленте за ним отвлекать. */ + background: rgb(0 0 0 / calc(0.88 * var(--viewer-dim))); + -webkit-backdrop-filter: blur(10px); + backdrop-filter: blur(10px); + color: #fff; + touch-action: none; + animation: media-viewer-in 160ms ease-out; +} + +/* Фото и под ним ряд «1/3 ↓» – одной группой по центру экрана. */ +.media-viewer__stage { + display: flex; + flex-direction: column; + align-items: center; + justify-content: center; + gap: var(--space-3); + min-height: 0; + padding: calc(56px + env(safe-area-inset-top)) 0 calc(var(--space-4) + env(safe-area-inset-bottom)); + transition: transform 160ms ease-out; +} + +.media-viewer__frame { display: grid; place-items: center; min-height: 0; max-width: 100%; } + +.media-viewer__media { + display: block; + max-width: 100vw; + max-height: calc(100dvh - 56px - 72px - env(safe-area-inset-top) - env(safe-area-inset-bottom)); + object-fit: contain; + user-select: none; + -webkit-user-drag: none; +} + +.media-viewer__controls { display: flex; align-items: center; justify-content: center; gap: var(--space-4); min-height: 44px; } +.media-viewer__counter { color: rgb(255 255 255 / 85%); font-size: var(--text-md); font-variant-numeric: tabular-nums; } +.media-viewer__counter[hidden] { display: none; } + +.media-viewer__bar { + position: absolute; + top: 0; + left: 0; + right: 0; + z-index: 1; + display: flex; + align-items: center; + min-height: calc(56px + env(safe-area-inset-top)); + padding: env(safe-area-inset-top) var(--space-1) 0; + transition: opacity 160ms ease; +} + +.media-viewer__btn, +.media-viewer__nav { + display: grid; + place-items: center; + width: 44px; + height: 44px; + padding: 0; + border: 0; + border-radius: var(--radius-pill); + background: transparent; + color: #fff; + cursor: pointer; +} + +.media-viewer__btn svg { width: 22px; height: 22px; } +.media-viewer__btn:hover { background: rgb(255 255 255 / 12%); } +.media-viewer__btn--round { background: rgb(255 255 255 / 16%); } +.media-viewer__btn--round:hover { background: rgb(255 255 255 / 26%); } +.media-viewer__btn:focus-visible, +.media-viewer__nav:focus-visible { outline: 2px solid #fff; outline-offset: -2px; } + +/* Стрелки листания – для компьютера; на телефоне листают смахиванием. */ +.media-viewer__nav { + position: absolute; + top: 50%; + z-index: 1; + background: rgb(255 255 255 / 14%); + transform: translateY(-50%); + transition: opacity 160ms ease; +} + +.media-viewer__nav svg { width: 22px; height: 22px; } +.media-viewer__nav--prev { left: var(--space-3); } +.media-viewer__nav--next { right: var(--space-3); } +.media-viewer__nav[hidden] { display: none; } + +@media (hover: none) { + .media-viewer__nav { display: none; } +} + +/* Нажатие на фото прячет панель – смотреть без помех. */ +.media-viewer.is-bare :is(.media-viewer__bar, .media-viewer__nav, .media-viewer__controls) { opacity: 0; pointer-events: none; } +.media-viewer__controls { transition: opacity 160ms ease; } + +@keyframes media-viewer-in { from { opacity: 0; } } + +@media (prefers-reduced-motion: reduce) { + .media-viewer { animation: none; } + .media-viewer__stage { transition: none; } +} diff --git a/shine-UI/styles/components/modal.css b/shine-UI/styles/components/modal.css index 7be74e01..90629800 100644 --- a/shine-UI/styles/components/modal.css +++ b/shine-UI/styles/components/modal.css @@ -39,3 +39,25 @@ .confirm-dialog__text { margin: 0; color: var(--text-secondary); font-size: .9375rem; line-height: 1.375rem; overflow-wrap: anywhere; } .confirm-dialog__danger { color: #fff; background: var(--danger); } :root[data-theme='dark'] .confirm-dialog__danger { color: var(--background); } + +/* Шторка с заголовком (js/components/sheet.js) */ +.sheet__card { display: grid; gap: 0; padding: 12px 16px 18px; border-radius: 22px; } +.sheet__head { display: flex; align-items: center; justify-content: space-between; gap: 8px; margin-bottom: 10px; } +.sheet__title { margin: 0; font-size: 1rem; } +.sheet__close { width: 36px; height: 36px; min-width: 36px; padding: 0; display: grid; place-items: center; border: 0; border-radius: 10px; background: transparent; color: var(--text-secondary); } +.sheet__close svg { width: 22px; height: 22px; } +.sheet__close:hover { background: var(--surface-raised); color: var(--text-primary); } +.sheet__body { display: grid; gap: 12px; font-size: .875rem; line-height: 1.3125rem; } +.sheet__body > p { margin: 0; } +.sheet__footer { display: flex; gap: 8px; margin-top: 18px; } +.sheet__footer > button { flex: 1; min-height: 44px; } + +/* «Поделиться» (js/components/share-sheet.js) */ +.share-sheet__content { display: grid; gap: 12px; } +.share-sheet__preview { padding: 12px; border-radius: 12px; background: var(--background); font-size: .875rem; line-height: 1.3125rem; } +.share-sheet__preview strong { display: block; margin-bottom: 5px; color: var(--text-secondary); font-size: .75rem; font-weight: 500; } +.share-sheet__preview p { margin: 0; display: -webkit-box; -webkit-line-clamp: 3; -webkit-box-orient: vertical; overflow: hidden; overflow-wrap: anywhere; } +.share-sheet__label { display: grid; gap: 5px; color: var(--text-secondary); font-size: .75rem; } +.share-sheet__link { min-height: 44px; padding: 9px 10px; border: 1px solid var(--border-control); border-radius: 10px; background: var(--surface-raised); color: var(--text-primary); font: inherit; font-size: .875rem; } +.share-sheet__copy, .share-sheet__system { width: 100%; min-height: 44px; display: inline-flex; align-items: center; justify-content: center; gap: 8px; } +.share-sheet__copy svg, .share-sheet__system svg { width: 20px; height: 20px; } diff --git a/shine-UI/styles/components/overflow-dots.css b/shine-UI/styles/components/overflow-dots.css index c4ccdf37..c2b25858 100644 --- a/shine-UI/styles/components/overflow-dots.css +++ b/shine-UI/styles/components/overflow-dots.css @@ -1,15 +1,15 @@ /* Shared overflow-dots trigger. */ /* ===== UI cleanup: main tabs, shared overflow menu and DM list (2026-08-22) ===== */ -/* Единое вертикальное троеточие для всех overflow/menu-кнопок. */ +/* Единое горизонтальное троеточие для всех overflow/menu-кнопок (как иконка more в ui-icon.js). */ .app-overflow-dots { - width: 8px; + width: 24px; height: 24px; display: inline-flex; - flex-direction: column; + flex-direction: row; align-items: center; justify-content: center; - gap: 3.5px; + gap: 4.8px; color: inherit; pointer-events: none; } @@ -17,14 +17,11 @@ .app-overflow-dots i { display: block; - width: 4px; - height: 4px; - flex: 0 0 4px; + width: 3.2px; + height: 3.2px; + flex: 0 0 3.2px; border-radius: 50%; background: currentColor; - box-shadow: - 0 0 5px color-mix(in srgb, var(--accent) 72%, transparent), - 0 0 10px color-mix(in srgb, var(--accent) 34%, transparent); } diff --git a/shine-UI/styles/components/primitives.css b/shine-UI/styles/components/primitives.css index e8450264..627ca9d8 100644 --- a/shine-UI/styles/components/primitives.css +++ b/shine-UI/styles/components/primitives.css @@ -604,3 +604,51 @@ body { overflow-x: hidden; } .empty-note { padding: var(--space-5) var(--space-4); text-align: center; color: var(--text-secondary); font-size: var(--text-sm); line-height: var(--leading-sm, 1.45); } .action-pair { display: grid; grid-template-columns: 1fr 1fr; gap: var(--space-2); } + + +/* Переключатель: . */ +.switch { + appearance: none; + -webkit-appearance: none; + flex: 0 0 auto; + width: 48px; + height: 28px; + margin: 0; + padding: 2px; + border: 1px solid var(--border-control); + border-radius: var(--radius-pill); + background: var(--surface-selected); + cursor: pointer; + transition: background-color var(--duration-fast) ease, border-color var(--duration-fast) ease; +} + +.switch::after { + content: ''; + display: block; + width: 22px; + height: 22px; + border-radius: 50%; + background: var(--text-secondary); + box-shadow: var(--shadow-sm); + transition: transform var(--duration-fast) ease, background-color var(--duration-fast) ease; +} + +.switch:checked { + border-color: var(--accent); + background: var(--accent); +} + +.switch:checked::after { + transform: translateX(20px); + background: var(--on-accent); +} + +.switch:focus-visible { + outline: 2px solid color-mix(in srgb, var(--accent) 82%, transparent); + outline-offset: 3px; +} + +.switch:disabled { + cursor: default; + opacity: .55; +} diff --git a/shine-UI/styles/components/tabs.css b/shine-UI/styles/components/tabs.css index 5483747b..b4188aeb 100644 --- a/shine-UI/styles/components/tabs.css +++ b/shine-UI/styles/components/tabs.css @@ -1,7 +1,9 @@ /* Shared tab geometry and tab primitives. */ +/* Переключатель той же высоты, что поле ввода и поиск (44 px), кнопки внутри – 34 px. */ .tabs { - min-height: 44px; + box-sizing: border-box; + min-height: var(--control-height); display: grid; grid-template-columns: repeat(2, 1fr); gap: 4px; @@ -12,13 +14,20 @@ } .tabs--three { grid-template-columns: repeat(3, minmax(0, 1fr)); } .tabs--auto { grid-template-columns: none; grid-auto-flow: column; grid-auto-columns: minmax(0, 1fr); } +/* Много коротких пунктов (4–5) в одну полосу: мельче шрифт и поля. */ +.tabs--dense { display: flex; gap: 2px; } +.tabs--dense .tab-btn { flex: 1 1 auto; min-width: 0; padding: 0 6px; font-size: var(--text-sm); white-space: nowrap; } +@media (max-width: 360px) { + .tabs--dense .tab-btn { padding: 0 4px; font-size: var(--text-xs); } +} .tab-btn { - min-height: 44px; + min-height: 34px; border: 0; background: transparent; - border-radius: 9px; - padding: 8px; + border-radius: 8px; + padding: 0 8px; + font-size: var(--text-md); color: var(--text-muted); cursor: pointer; } diff --git a/shine-UI/styles/components/topbar.css b/shine-UI/styles/components/topbar.css index 5124c1fe..2dff3c18 100644 --- a/shine-UI/styles/components/topbar.css +++ b/shine-UI/styles/components/topbar.css @@ -1,5 +1,5 @@ :root { --app-topbar-base-height: 56px; --app-topbar-title-size: 1.0625rem; --app-topbar-bg: var(--background); --app-topbar-fg: var(--text-primary); --app-topbar-gold: var(--text-primary); --app-topbar-blue-glow: transparent; --app-topbar-blue-glow-soft: transparent; } -.topbar { width: 100%; min-height: calc(56px + env(safe-area-inset-top)); padding: env(safe-area-inset-top) 0 0; display: grid; grid-template-columns: minmax(44px, 1fr) minmax(0, auto) minmax(44px, 1fr); align-items: center; gap: 4px; background: var(--background); } +.topbar { width: 100%; min-height: calc(56px + env(safe-area-inset-top)); padding: env(safe-area-inset-top) 0 0; display: grid; grid-template-columns: minmax(44px, 1fr) minmax(0, auto) minmax(44px, 1fr); align-items: center; gap: 4px; background: var(--surface); border-bottom: 1px solid var(--border-subtle); } .topbar__left, .topbar__center, .topbar__right { display: flex; min-width: 0; align-items: center; } .topbar__center { justify-content: center; } .topbar__right { justify-content: flex-end; } @@ -15,6 +15,14 @@ .header-icon-svg { display: block; width: 22px; height: 22px; } .topbar__back svg { width: 24px; height: 24px; stroke-width: 2.2; } .topbar__action svg { width: 22px; height: 22px; } -.topbar--root { grid-template-columns: auto minmax(0, 1fr) auto; } -.topbar--root .topbar__center { justify-content: flex-start; } -.topbar--root .topbar__title { font-size: 1.5rem; line-height: 1.875rem; } +/* Корневые разделы (Чаты, Каналы, Связи, Уведомления, Профиль) – заголовок по центру, как на всех экранах, но крупнее. */ +.topbar--root .topbar__title { font-size: 1.5rem; line-height: 1.875rem; font-weight: 700; } + +/* Шапка-визитка: аватар и две строки слева (канал, собеседник) */ +.topbar--identity { grid-template-columns: auto minmax(0, 1fr) auto; } +.topbar--identity .topbar__center { justify-content: flex-start; } +.topbar-identity { display: flex; align-items: center; gap: 10px; min-width: 0; max-width: 100%; min-height: 44px; padding: 0 4px; border: 0; border-radius: 12px; background: transparent; color: var(--text-primary); font: inherit; text-align: left; cursor: pointer; } +.topbar-identity:disabled { cursor: default; } +.topbar-identity__text { display: grid; min-width: 0; } +.topbar-identity__title { font-size: 1rem; line-height: 1.3; font-weight: 600; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } +.topbar-identity__sub { margin-top: 2px; color: var(--text-secondary); font-size: .75rem; line-height: 1.125rem; font-weight: 400; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } diff --git a/shine-UI/styles/features/channel-thread.css b/shine-UI/styles/features/channel-thread.css index d3c543f6..d8211831 100644 --- a/shine-UI/styles/features/channel-thread.css +++ b/shine-UI/styles/features/channel-thread.css @@ -1,7 +1,44 @@ -/* Ветка сохраняет ширину текста на любой глубине. */ +/* Обсуждение (макет V4): контекст записи, «Комментарии · N», плоский список, строка ввода. */ +.channels-screen--thread { gap: 0; } .thread-block { display: grid; gap: 0; min-width: 0; } -.thread-node-level { margin-left: 0; } -.thread-block--replies > .section-title { padding: 16px 0 8px; margin: 0; color: var(--text-secondary); font-size: .875rem; font-weight: 600; } -.thread-node-heading { color: var(--text-secondary); font-size: .8125rem; } -.thread-node-card .channel-message-avatar.avatar { width: 32px; height: 32px; min-width: 32px; min-height: 32px; } -.thread-history-divider { border-top: 1px solid var(--border-subtle); margin: 8px 0; } +.thread-context { padding: 10px 0 8px; border-bottom: 1px solid var(--border-subtle); font-size: .875rem; line-height: 1.25rem; } +.thread-block--ancestors .thread-context { opacity: .8; } +.thread-context__text { margin: 0; display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; overflow: hidden; white-space: pre-wrap; overflow-wrap: anywhere; } +.thread-context.is-expanded .thread-context__text { display: block; } +.thread-context__meta { display: flex; align-items: center; gap: 12px; min-height: 32px; color: var(--text-secondary); font-size: .75rem; } +.thread-context__expand, .thread-context__open { min-height: 32px; padding: 0 4px; border: 0; background: transparent; color: var(--action); font: inherit; font-size: .75rem; cursor: pointer; } +.thread-context__open { margin-left: auto; display: inline-flex; align-items: center; gap: 4px; } +.thread-context__open svg { width: 14px; height: 14px; } + +.thread-section-title { margin: 12px 0 4px; font-size: .8125rem; font-weight: 600; color: var(--text-primary); } +.channels-screen .thread-comment { display: block; margin: 0 calc(-1 * var(--page-gutter)); padding: 7px var(--page-gutter) 5px; border: 0; border-radius: 0; background: transparent; scroll-margin: 16px; } +.channels-screen .thread-comment + .thread-comment { border-top: 1px solid var(--divider-soft); } +.thread-comment.is-highlight { background: var(--surface-selected); box-shadow: inset 3px 0 var(--accent); } +.thread-comment__person { display: flex; align-items: center; gap: 7px; min-height: 26px; margin-bottom: 4px; font-size: .875rem; font-weight: 600; } +.thread-comment__who { display: inline-flex; align-items: center; gap: 7px; min-width: 0; padding: 0; border: 0; background: transparent; color: var(--text-primary); font: inherit; cursor: pointer; } +.thread-comment__who .avatar.thread-comment__avatar { width: 24px; height: 24px; min-width: 24px; min-height: 24px; font-size: 11px; } +.thread-comment__name { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; min-width: 0; } +.thread-comment__badge { padding: 1px 5px; border-radius: 5px; background: var(--surface-selected); color: var(--action); font-size: .625rem; font-weight: 400; white-space: nowrap; } +.thread-comment__person time { margin-left: auto; flex-shrink: 0; color: var(--text-secondary); font-size: .75rem; font-weight: 400; } +.thread-comment__text { margin: 0; font-size: .9375rem; line-height: 1.4375rem; white-space: pre-wrap; overflow-wrap: anywhere; } +.thread-comment__actions { display: flex; align-items: center; gap: 12px; margin-top: 2px; color: var(--text-secondary); } +.thread-comment__actions > button { min-height: 32px; min-width: 32px; padding: 0 4px; display: inline-flex; align-items: center; gap: 5px; border: 0; border-radius: 8px; background: transparent; color: inherit; font: inherit; font-size: .75rem; cursor: pointer; } +.thread-comment__actions .thread-comment__reply { padding-left: 0; color: var(--action); } +.thread-comment__actions svg { width: 21px; height: 21px; } +.thread-comment__actions .thread-comment__more { margin-left: auto; } +.thread-comment__actions .thread-comment__more svg { width: 24px; height: 24px; } + +.thread-quote { display: block; width: 100%; margin: 0 0 7px; padding: 5px 9px; border: 0; border-left: 2px solid var(--quote-line); border-radius: 0 6px 6px 0; background: var(--quote-bg); color: var(--text-secondary); font: inherit; font-size: .75rem; line-height: 1.125rem; text-align: left; cursor: pointer; } +.thread-quote strong { display: block; color: var(--action); font-weight: 500; } +.thread-quote span { display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; overflow: hidden; } +button.thread-quote:hover { background: var(--surface); } +.thread-return { position: fixed; left: 50%; bottom: calc(96px + env(safe-area-inset-bottom)); transform: translateX(-50%); z-index: 5; padding: 9px 12px; border: 1px solid var(--border-subtle); border-radius: 20px; background: var(--surface-raised); color: var(--text-primary); font: inherit; font-size: .75rem; white-space: nowrap; cursor: pointer; } +.thread-empty { padding: 36px 20px; text-align: center; } + +.thread-composer { display: grid; gap: 8px; } +.thread-replying { display: flex; gap: 8px; align-items: flex-start; } +.thread-replying[hidden] { display: none; } +.thread-replying .thread-quote { margin: 0; min-width: 0; cursor: default; } +.thread-replying__cancel { width: 32px; height: 32px; flex-shrink: 0; padding: 0; display: grid; place-items: center; border: 0; background: transparent; color: var(--text-secondary); cursor: pointer; } +.thread-replying__cancel svg { width: 20px; height: 20px; } +.thread-composer__emoji { max-height: 260px; overflow: auto; } diff --git a/shine-UI/styles/features/channel.css b/shine-UI/styles/features/channel.css index 0c82a705..2e26fd99 100644 --- a/shine-UI/styles/features/channel.css +++ b/shine-UI/styles/features/channel.css @@ -6,10 +6,11 @@ .channels-screen .channel-message-card.is-focus-flash { background: var(--surface-selected); } .channel-system-event-card { padding: 8px; margin: 8px auto; width: fit-content; max-width: 100%; color: var(--text-secondary); font-size: .75rem; text-align: center; } .channel-meta-details-grid { display: grid; grid-template-columns: auto minmax(0,1fr); gap: 8px; overflow-wrap: anywhere; } -.channel-profile-avatar { width: 96px; height: 96px; border-radius: 50%; overflow: hidden; } +.channel-profile-avatar { width: var(--channel-avatar-size, 96px); height: var(--channel-avatar-size, 96px); min-width: var(--channel-avatar-size, 96px); border-radius: calc(var(--channel-avatar-size, 96px) * .28); overflow: hidden; color: var(--accent); font-size: calc(var(--channel-avatar-size, 96px) * .5); } .channel-profile-avatar img { width: 100%; height: 100%; object-fit: cover; } .channel-profile-modal-head { display: flex; gap: 12px; align-items: center; } -.channel-main-action { min-height: 44px; border-radius: 12px; padding: 10px 16px; color: var(--on-accent); background: var(--accent); } +.channel-main-action { width: 100%; min-height: 44px; display: inline-flex; align-items: center; justify-content: center; gap: 8px; border-radius: 12px; padding: 0 16px; color: var(--on-accent); background: var(--accent); font-weight: 600; } +.channel-main-action svg { width: 20px; height: 20px; } .channel-back-btn { min-height: 44px; color: var(--accent); } .entrypoint-history-list { display: grid; gap: 8px; max-height: 58vh; overflow: auto; } .entrypoint-history-item { display: grid; gap: 8px; text-align: left; padding: 12px; border-radius: 12px; background: var(--surface); color: var(--text-primary); } @@ -24,7 +25,7 @@ .channel-about-hero { display: grid; justify-items: center; gap: 4px; padding: 8px 16px 0; text-align: center; } .channel-about-avatar-slot { margin-bottom: 8px; } -.channel-about-avatar.avatar { width: 88px; height: 88px; min-width: 88px; min-height: 88px; font-size: 32px; } +.channel-about-avatar.avatar { width: 80px; height: 80px; min-width: 80px; min-height: 80px; border-radius: 24px; font-size: 36px; color: var(--accent); } .channel-about-title { margin: 0; color: var(--text-primary); font-size: 1.375rem; line-height: 1.75rem; font-weight: 600; overflow-wrap: anywhere; } .channel-about-subline { color: var(--text-secondary); font-size: .875rem; line-height: 1.25rem; overflow-wrap: anywhere; } @@ -416,3 +417,4 @@ grid-column: 1 / -1; } } +.channel-about-tiles:empty { display: none; } diff --git a/shine-UI/styles/features/channels-common.css b/shine-UI/styles/features/channels-common.css index 25d0be32..9827bc6c 100644 --- a/shine-UI/styles/features/channels-common.css +++ b/shine-UI/styles/features/channels-common.css @@ -42,7 +42,8 @@ .deleted-message-pill { min-height: 44px; text-align: left; color: var(--text-secondary); padding: 8px 0; } .channel-header-title, .channel-header-owner { display: block; max-width: 100%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; } .channel-header-owner { color: var(--text-secondary); font-size: .75rem; line-height: 1rem; font-weight: 400; } -.channel-composer { display: flex; gap: 8px; padding: 8px 0; background: var(--background); } +/* Нижняя панель экранов канала: поверхность с линией сверху, как шапка */ +.channel-composer { display: flex; gap: 8px; margin: 0 -12px; padding: 9px 12px calc(11px + env(safe-area-inset-bottom)); background: var(--surface); border-top: 1px solid var(--border-subtle); } .channel-compose-bar { width: 100%; min-height: 44px; @@ -77,29 +78,36 @@ .thread-reply-context { color: var(--text-secondary); font-size: .75rem; line-height: 1.125rem; border-left: 2px solid var(--border-control); padding-left: 10px; overflow-wrap: anywhere; } @media (prefers-reduced-motion: reduce) { .channels-screen *, .channel-composer * { animation: none; scroll-behavior: auto; transition: none; } } -.channels-screen .channel-message-card.channel-message-card--owner { - gap: 6px; - margin: 0 0 8px; - padding: 10px 12px 2px 14px; - border: 1px solid var(--border-subtle); - border-radius: 16px; - background: var(--surface); - justify-self: start; - width: fit-content; - min-width: min(100%, 17rem); - max-width: 100%; -} -.channels-screen .channel-message-card--owner:has(.message-attachment-carousel) { width: 100%; } +/* Запись автора в его канале (макет V4): плоская, на всю ширину, между записями — линия с отступами */ +.channels-screen .channel-message-card.channel-message-card--owner { gap: 0; margin: 0; padding: 20px 0 8px; border: 0; position: relative; } +.channels-screen .channel-message-card--owner + .channel-message-card--owner::before { content: ''; position: absolute; top: 0; left: 0; right: 0; height: 1px; background: var(--border-subtle); } +.channels-screen .channel-message-card--owner .channel-message-body { font-size: 1rem; line-height: 1.52; } .channel-message-card--owner .channel-message-head-row[hidden] { display: none; } -.channel-message-card--owner .channel-message-body { line-height: 1.375rem; } -.channel-message-card--owner .channel-message-actions { gap: 0; margin-left: -8px; flex-wrap: nowrap; } -.channel-message-card--owner .channel-action-item { min-width: 40px; min-height: 40px; padding: 6px 8px; gap: 4px; } -.channel-message-card--owner .channel-action-icon svg { width: 20px; height: 20px; } -.channel-message-meta { display: flex; align-items: center; gap: 0; margin-left: auto; min-width: 0; } +.channel-message-card--owner .message-attachment-carousel { width: calc(100% + 2 * var(--page-gutter)); max-width: none; margin: 0 calc(-1 * var(--page-gutter)) 14px; } +.channel-message-card--owner .message-attachment-carousel-viewport { border: 0; border-radius: 0; } +.topbar-identity .avatar.channel-profile-avatar { --channel-avatar-size: 40px; width: 40px; height: 40px; min-width: 40px; min-height: 40px; font-size: 22px; border-radius: 11px; } +.channel-message-card--owner .channel-message-actions { gap: 0; margin: 6px -8px 0; min-height: 50px; flex-wrap: nowrap; } +/* Равный шаг иконок: каждое действие – ячейка 56 px, иконка у левого края, счётчик внутри ячейки (влезает и «999»). */ +.channel-message-card--owner .channel-action-item { width: 56px; min-width: 56px; min-height: 44px; padding: 0 0 0 8px; gap: 5px; justify-content: flex-start; border-radius: 10px; font-variant-numeric: tabular-nums; } +.channel-message-card--owner .channel-action-discussion { width: auto; padding-right: 8px; } +.channel-message-card--owner .channel-action-icon svg { width: 23px; height: 23px; } +.channel-message-card--owner .channel-action-share .channel-action-icon svg { width: 25px; height: 25px; } +.channel-action-item.is-liked svg { fill: currentColor; } +.channel-action-faces { display: inline-flex; align-items: center; margin-left: 2px; padding-right: 3px; } +.channel-action-faces .avatar.channel-action-face { width: 22px; height: 22px; min-width: 22px; min-height: 22px; font-size: 10px; border: 2px solid var(--background); } +.channel-action-faces .channel-action-face + .channel-action-face { margin-left: -6px; } +.channel-message-meta { display: flex; align-items: center; gap: var(--space-1); margin-left: auto; min-width: 0; padding-left: 4px; } .channel-message-meta .channel-message-time { white-space: nowrap; } .channel-message-meta .channel-message-time::before { content: none; } -.channel-message-meta .channel-message-more { width: 40px; height: 40px; min-height: 40px; margin: 0 -4px 0 0; padding: 0; font-size: 20px; } -.channel-message-card--owner .attachment-carousel, -.channel-message-card--owner [class*='attachment'] { border-radius: 12px; } +.channel-message-meta .channel-message-more { display: inline-grid; place-items: center; width: 36px; height: 44px; min-height: 44px; margin: 0 -4px 0 0; padding: 0; } +.channel-message-more svg { display: block; width: 20px; height: 20px; } +@media (max-width: 360px) { .channel-message-card--owner .channel-action-item { width: 50px; min-width: 50px; } .channel-message-meta .channel-message-time { font-size: .6875rem; } } + +/* Нижняя панель ленты: «Новая запись» у владельца, «Подписаться» у читателя */ +.channel-new-post { width: 100%; min-height: 44px; display: inline-flex; align-items: center; justify-content: center; gap: 8px; border: 0; border-radius: 12px; background: var(--surface-selected); color: var(--action); font: inherit; font-weight: 600; cursor: pointer; } +.channel-new-post svg { width: 21px; height: 21px; } +.channel-new-post:hover { background: color-mix(in srgb, var(--surface-selected) 85%, var(--text-primary)); } +.channel-new-post:focus-visible { outline: 2px solid var(--focus-ring); outline-offset: 2px; } .channels-screen--channel, .channels-screen--thread { padding-bottom: 8px; } +.channel-message-card--owner .message-attachment-media { height: auto; max-height: 70vh; object-fit: cover; } diff --git a/shine-UI/styles/features/channels-list.css b/shine-UI/styles/features/channels-list.css index 8351eb4f..43015cef 100644 --- a/shine-UI/styles/features/channels-list.css +++ b/shine-UI/styles/features/channels-list.css @@ -24,6 +24,7 @@ .channels-list-controls { display: grid; gap: 12px; + padding-top: var(--page-top-gap); } .channels-inline-search { diff --git a/shine-UI/styles/features/chat.css b/shine-UI/styles/features/chat.css index b7149391..7b8b93f5 100644 --- a/shine-UI/styles/features/chat.css +++ b/shine-UI/styles/features/chat.css @@ -850,26 +850,19 @@ /* Поле сообщения занимает почти всю ширину; действия прижаты к правому краю. */ -.composer-slot:has(> .dm-chat-input) { - padding-left: 0; - padding-right: 4px; -} +/* Нижняя панель чата — поверхность с линией сверху, как у канала и обсуждения */ .dm-chat-input { grid-template-columns: minmax(0, 1fr) auto; align-items: end; position: relative; z-index: 10; - margin-inline: 0; - padding: 10px 0; - border-top: 0; - background: transparent; - backdrop-filter: none; - -webkit-backdrop-filter: none; - gap: 4px; - padding-left: 0; - padding-right: 0; + margin-inline: calc(-1 * var(--page-gutter)); + padding: 9px var(--page-gutter) calc(11px + env(safe-area-inset-bottom)); + border-top: 1px solid var(--border-subtle); + background: var(--surface); + gap: 6px; } @@ -891,98 +884,16 @@ -.chat-header-peer-btn { - width: 100%; - min-width: 0; - min-height: 46px; - padding: 2px 0; - border-radius: 12px; - display: flex; - align-items: center; - justify-content: flex-start; - gap: 7px; - text-align: left; - cursor: pointer; -} - - -.chat-header-peer-btn .chat-header-avatar-slot { - flex: 0 0 40px; -} - - -.chat-header-peer-text { - min-width: 0; - display: flex; - flex-direction: column; - align-items: flex-start; - justify-content: center; - gap: 2px; -} - - -.chat-header-peer-name, -.chat-header-peer-meta { - display: block; - max-width: 100%; - overflow: hidden; - text-overflow: ellipsis; - white-space: nowrap; -} - - -.chat-header-peer-name { - font-size: 14px; - line-height: 1.15; - font-weight: 650; - color: var(--text-primary); -} - - -.chat-header-peer-meta { - font-size: 11px; - line-height: 1.15; - font-weight: 500; - color: var(--text-secondary); -} - - -/* ===== DM header regression fix (2026-09-02) ===== - * The peer identity button intentionally spans the whole free header area. - * Its avatar uses a 119% glass overlay, so neither the center cell nor the - * button may clip overflow. Text keeps its own ellipsis boundary instead. - */ - - -.chat-header-peer-btn { - overflow: visible; - padding-inline: 2px; -} - - -.chat-header-peer-btn .chat-header-avatar-slot { - width: 44px; - height: 44px; - min-width: 44px; - min-height: 44px; - flex: 0 0 44px; - overflow: visible; -} - - -.chat-header-peer-btn .chat-header-avatar-slot .chat-header-avatar { - overflow: visible; -} - - -.chat-header-peer-text { - flex: 1 1 auto; - overflow: hidden; -} +/* Шапка чата — общая «визитка» (topbar.css .topbar-identity). У аватара стеклянный ободок на 119%, + * поэтому ни кнопка, ни слот аватара не обрезают содержимое; текст обрезается сам. */ +.chat-header-peer-btn { width: 100%; overflow: visible; } +.chat-header-peer-btn .chat-header-avatar-slot { width: 36px; height: 36px; min-width: 36px; flex: 0 0 36px; overflow: visible; } +.chat-header-peer-btn .chat-header-avatar-slot .avatar.chat-header-avatar { width: 36px; height: 36px; min-width: 36px; min-height: 36px; overflow: visible; } +.chat-header-peer-text { flex: 1 1 auto; overflow: hidden; } /* Shell state + Chat-owned composer adjustment (moved out of app-shell.css). */ .app-shell--scroll-nested.keyboard-open .composer-slot .dm-chat-input { - padding-bottom: 0; + padding-bottom: 9px; } @@ -1393,35 +1304,28 @@ margin-top: 2px; } -.chat-header-peer-btn { border: 0; background: transparent; color: inherit; font: inherit; } -.chat-header-peer-btn:hover { background: var(--surface); } -.chat-header-peer-btn:focus-visible { outline: 2px solid var(--focus-ring); outline-offset: -2px; } -.chat-header-peer-name { font-size: var(--text-md); font-weight: var(--weight-bold); } -.chat-header-peer-meta { font-size: var(--text-xs); } .dm-chat-screen .bubble { - max-width: min(80%, 34rem); - padding: 8px 12px 6px; - border-radius: var(--radius-lg); + max-width: min(85%, 34rem); + padding: 10px 12px 7px; + border-radius: 17px; color: var(--text-primary); - font-size: var(--text-md); - line-height: var(--leading-md); + font-size: .9375rem; + line-height: 1.375rem; box-shadow: none; + overflow-wrap: anywhere; } -.dm-chat-screen .bubble.in { - background: var(--surface); - border: 1px solid var(--border-subtle); - border-bottom-left-radius: var(--radius-xs); - border-top-left-radius: var(--radius-lg); -} -.dm-chat-screen .bubble.out { - background: color-mix(in srgb, var(--accent) 24%, var(--surface)); - border: 1px solid color-mix(in srgb, var(--accent) 30%, var(--border-subtle)); - border-bottom-right-radius: var(--radius-xs); - border-top-right-radius: var(--radius-lg); -} -.dm-chat-screen .bubble-meta { font-size: .6875rem; line-height: 1rem; color: var(--text-secondary); } -.dm-chat-screen .bubble-status--read { color: var(--accent); } +.dm-chat-screen .bubble.in { background: var(--surface); border-bottom-left-radius: 5px; } +.dm-chat-screen .bubble.out { background: var(--bubble-out); border-bottom-right-radius: 5px; } +/* Время и статус — в конце последней строки (эксперимент V4, принят); не влезают — переносятся */ +.dm-chat-screen .bubble-text { display: inline; } +.dm-chat-screen .bubble-meta { float: right; margin: 5px 0 0 10px; display: inline-flex; align-items: center; gap: 4px; font-size: .6875rem; line-height: 1rem; color: color-mix(in srgb, var(--text-secondary) 70%, var(--text-primary)); } +.dm-chat-screen .bubble::after { content: ''; display: table; clear: both; } +.dm-chat-screen .bubble-status { display: inline-flex; min-width: 0; color: inherit; text-shadow: none; } +.dm-chat-screen .bubble-status svg { width: 16px; height: 16px; } +.dm-chat-screen .bubble-status--read { color: var(--action); } +.dm-chat-screen .bubble-status--failed { color: var(--danger); } +.dm-chat-screen .bubble-delivery-note { clear: both; } .dm-day-separator { display: flex; justify-content: center; margin: 8px 0; } .dm-day-separator span { padding: 3px 10px; border-radius: var(--radius-pill); color: var(--text-secondary); background: var(--surface); border: 1px solid var(--border-subtle); font-size: var(--text-xs); line-height: var(--leading-xs); } @@ -1431,7 +1335,7 @@ border: 1px solid var(--border-control); border-radius: 22px; color: var(--text-primary); - background: var(--surface); + background: var(--surface-raised); text-shadow: none; caret-color: var(--accent); font-size: 1rem; diff --git a/shine-UI/styles/features/developer-tools.css b/shine-UI/styles/features/developer-tools.css index 20486b5f..88160a48 100644 --- a/shine-UI/styles/features/developer-tools.css +++ b/shine-UI/styles/features/developer-tools.css @@ -1,27 +1,5 @@ /* Diagnostics/admin/developer UI styles. */ -.key-storage-option { - gap: 6px; -} - - -.key-storage-option__description { - margin: 0; -} - - -.key-storage-note { - margin: 0; - line-height: 1.45; -} - - -.key-storage-note--strong { - font-size: 17px; - font-weight: 700; - color: var(--text-primary); -} - .pwa-diag-list { gap: 8px; @@ -200,3 +178,7 @@ .arweave-uploads-menu-btn .app-overflow-dots { margin: auto; } + +/* Проверка Solana RPC: длинные адреса узлов переносятся, а не раздвигают экран */ +.solana-rpc-card { min-width: 0; } +.solana-rpc-url, .solana-rpc-details { min-width: 0; overflow-wrap: anywhere; } diff --git a/shine-UI/styles/features/devices.css b/shine-UI/styles/features/devices.css index bf7c5e14..4880eb46 100644 --- a/shine-UI/styles/features/devices.css +++ b/shine-UI/styles/features/devices.css @@ -151,13 +151,17 @@ } +/* QR для второго устройства: по центру карточки, во всю доступную ширину до 280 px. + * Фон всегда светлый — тёмный QR на тёмном фоне камеры читают плохо. */ .qr-image { - width: 64px; - height: 64px; - border-radius: 8px; + width: min(280px, 100%); + aspect-ratio: 1; + padding: 12px; + border-radius: 16px; border: 1px solid var(--border-subtle); - background: var(--text-primary); + background: #ffffff; } +.qr-image svg { display: block; width: 100%; height: 100%; } /* Pairing approve/reject use their semantic button roles; legacy green/red surfaces were not observable in Stage 3.1. */ @@ -331,3 +335,62 @@ .key-list > .key-card { padding: 12px 14px; border: 0; border-radius: 0; background: transparent; } .key-list > .key-card + .key-card { border-top: 1px solid var(--border-subtle); } .key-list .key-card__hint { font-size: var(--text-sm); } + + +/* Единственный видимый сценарий подключения другого устройства. */ +.pairing-guide-card { + gap: 16px; + overflow: hidden; + border-color: color-mix(in srgb, var(--accent) 24%, var(--border-subtle)); + background: + radial-gradient(circle at 100% 0%, color-mix(in srgb, var(--accent) 12%, transparent), transparent 42%), + var(--surface); +} + +.pairing-guide__heading { + display: grid; + gap: 5px; +} + +.pairing-guide__eyebrow { + color: var(--accent); + font-size: var(--text-xs); + font-weight: var(--weight-bold); + letter-spacing: .08em; + text-transform: uppercase; +} + +.pairing-guide__title { + margin: 0; + font-size: var(--text-lg); +} + +.pairing-guide__steps { + display: grid; + gap: 12px; + margin: 0; + padding: 0; + list-style: none; +} + +.pairing-guide__steps li { + display: grid; + grid-template-columns: 30px minmax(0, 1fr); + align-items: start; + gap: 11px; + color: var(--text-secondary); + line-height: 1.45; +} + +.pairing-guide__step-number { + display: grid; + place-items: center; + width: 30px; + height: 30px; + border: 1px solid color-mix(in srgb, var(--accent) 34%, var(--border-subtle)); + border-radius: 999px; + color: var(--text-primary); + background: color-mix(in srgb, var(--accent) 12%, var(--surface)); + font-size: var(--text-sm); + font-weight: var(--weight-bold); +} diff --git a/shine-UI/styles/features/messages.css b/shine-UI/styles/features/messages.css index e326b891..c74fa5fe 100644 --- a/shine-UI/styles/features/messages.css +++ b/shine-UI/styles/features/messages.css @@ -757,7 +757,7 @@ button.dm-via-node:hover { border-color: color-mix(in srgb, var(--rel-link) 50%, .dm-row-time { font-size: var(--text-xs); font-weight: 400; color: var(--text-secondary); } .dm-contact-note { flex-shrink: 0; padding: 0; border: 0; border-radius: 0; background: none; color: var(--rel-contact); font-size: var(--text-xs); font-weight: var(--weight-medium); } .dm-contact-note--close_friend { color: var(--rel-family); } -.dm-filter-row { margin-bottom: var(--space-1); } +.dm-filter-row { margin: 0 0 var(--space-1); } .dm-row-meta-col { align-self: stretch; display: flex; flex-direction: column; align-items: flex-end; justify-content: center; gap: 6px; } .dm-row-meta-line { display: flex; align-items: center; gap: 0; } .dm-unread-badge { min-width: 20px; height: 20px; padding: 0 6px; display: grid; place-items: center; border-radius: var(--radius-pill); color: var(--on-accent); background: var(--accent); border: 0; font-size: var(--text-xs); font-weight: var(--weight-bold); } @@ -766,6 +766,4 @@ button.dm-via-node:hover { border-color: color-mix(in srgb, var(--rel-link) 50%, .dm-divider::before, .dm-divider::after { content: none; } .contact-search-results { gap: 0; margin-top: var(--space-3); } .contact-search-results .contact-search-results-title { margin: 0 0 var(--space-1); color: var(--text-secondary); font-size: var(--text-xs); } -.dm-filter-row { gap: 6px; } -.dm-filter-row .chip { padding: 0 12px; } .dm-row-last-message.is-encrypted { font-style: italic; } diff --git a/shine-UI/styles/features/notifications.css b/shine-UI/styles/features/notifications.css index 99a9445f..774d9c26 100644 --- a/shine-UI/styles/features/notifications.css +++ b/shine-UI/styles/features/notifications.css @@ -1,203 +1,88 @@ -/* Notifications feature styles. */ +/* Уведомления: плоский список как в чатах – аватар, имя и время, ниже текст; тонкие разделители от текста. */ +.notifications-screen { align-content: start; } +.notifications-screen .notification-feed-tabs { margin-bottom: var(--space-1); } -/* ===== Notifications glass style ===== */ -.notifications-screen { - position: relative; - isolation: isolate; - color: var(--text-primary); - min-height: 100%; - align-content: start; -} +.notifications-list { display: grid; } - -.notifications-screen::before { - content: ""; - position: absolute; - inset: -12px -12px 0; - z-index: -1; - pointer-events: none; - background: - radial-gradient(320px 320px at 86% 12%, color-mix(in srgb, var(--rel-contact) 20%, transparent), transparent 72%), - radial-gradient(280px 280px at 18% 82%, color-mix(in srgb, var(--rel-contact) 14%, transparent), transparent 72%), - radial-gradient(260px 260px at 70% 65%, color-mix(in srgb, var(--warning) 12%, transparent), transparent 75%), - var(--surface); -} - - -.notifications-screen .tabs { - background: var(--surface); - backdrop-filter: blur(18px); - -webkit-backdrop-filter: blur(18px); - border: 1px solid transparent; - border-radius: 16px; -} - - -.notifications-screen .tab-btn { - color: var(--text-secondary); -} - - -.notifications-screen .tab-btn.active { - background: color-mix(in srgb, var(--warning) 12%, transparent); - border: 1px solid transparent; - color: var(--warning); -} - - -.notifications-screen .notifications-list > .card { - background: var(--surface); - backdrop-filter: blur(24px); - -webkit-backdrop-filter: blur(24px); - border: 1px solid var(--border-subtle); - border-radius: 20px; - box-shadow: 0 0 60px color-mix(in srgb, var(--accent) 12%, transparent); -} -.notifications-screen::before { - content: none; -} - - -/* Contacts overflow menu body portal: avoids topbar overflow hit-testing on desktop/Android. */ - - -/* ===== Notifications: social event cards ===== */ -.notifications-screen .notification-card { - gap: 10px; -} - - -.notification-identity { - display: flex; - align-items: center; - gap: 10px; - min-width: 0; -} - - -.notification-avatar { - width: 40px; - height: 40px; - min-width: 40px; - min-height: 40px; - flex: 0 0 auto; -} - - -.notification-identity-text { - min-width: 0; - flex: 1 1 auto; -} - - -.notification-identity-primary { - display: flex; - align-items: baseline; - gap: 6px; - min-width: 0; - flex-wrap: wrap; -} - - -.notification-person-name { - color: var(--text-primary); - font-weight: 700; - overflow-wrap: anywhere; -} - - -.notification-login, -.notification-time-separator, -.notification-time { - color: var(--text-secondary); - font-size: 12px; -} - - -.notification-action, -.notification-content { +.notification-group-title { margin: 0; -} - - -.notification-action { + padding: var(--space-3) 0 var(--space-1); color: var(--text-secondary); - font-size: 13px; + font-size: var(--text-xs); + line-height: var(--leading-xs); + font-weight: var(--weight-bold); } +.notification-card { + position: relative; + display: grid; + grid-template-columns: 40px minmax(0, 1fr); + gap: var(--space-3); + padding: var(--space-3) 0 0; + border-radius: var(--radius-md); +} -.notification-content { +.notification-avatar { width: 40px; height: 40px; min-width: 40px; min-height: 40px; } + +.notification-card__body { + display: grid; + gap: 2px; + min-width: 0; + padding-bottom: var(--space-3); + border-bottom: 1px solid var(--divider-soft); +} + +.notification-card__head { display: flex; align-items: baseline; gap: var(--space-2); min-width: 0; } + +.notification-card__name { + flex: 1 1 auto; + min-width: 0; color: var(--text-primary); - font-size: 15px; - line-height: 1.45; + font-size: var(--text-md); + font-weight: var(--weight-bold); + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.notification-card__time { flex: 0 0 auto; color: var(--text-secondary); font-size: var(--text-xs); } + +/* Непрочитанное: точка-акцент перед временем. */ +.notification-card--new .notification-card__time::before { + content: ""; + display: inline-block; + width: 7px; + height: 7px; + margin-right: 6px; + border-radius: 50%; + background: var(--accent); + vertical-align: 1px; +} + +.notification-card__action { margin: 0; color: var(--text-secondary); font-size: var(--text-sm); line-height: var(--leading-sm); } + +.notification-card__text { + margin: 0; + color: var(--text-primary); + font-size: var(--text-md); + line-height: var(--leading-md); white-space: pre-wrap; overflow-wrap: anywhere; + display: -webkit-box; + -webkit-line-clamp: 3; + -webkit-box-orient: vertical; + overflow: hidden; } +.notification-engagement { display: flex; align-items: center; gap: var(--space-4); padding-top: var(--space-1); color: var(--text-secondary); } +.notification-engagement-item { display: inline-flex; align-items: center; gap: 4px; font-size: var(--text-xs); line-height: 1; } +.notification-engagement-icon { display: inline-flex; } +.notification-engagement-icon svg { width: 14px; height: 14px; } -.notification-engagement { - display: flex; - align-items: center; - gap: 18px; - flex-wrap: wrap; - padding-top: 2px; - color: var(--text-secondary); -} +.notification-card--clickable { cursor: pointer; } +.notification-card--clickable:hover { background: color-mix(in srgb, var(--surface-selected) 45%, transparent); } +.notification-card--clickable:focus-visible { outline: 2px solid var(--focus-ring); outline-offset: 2px; } - -.notification-engagement-item { - display: inline-flex; - align-items: center; - gap: 5px; - min-width: 24px; - font-size: 12px; - line-height: 1; -} - - -.notification-engagement-icon { - font-size: 15px; -} - - - -.notifications-screen .notification-card--clickable { - cursor: pointer; - transition: transform 120ms ease, border-color 120ms ease, background-color 120ms ease; -} - - -.notifications-screen .notification-card--clickable:hover, -.notifications-screen .notification-card--clickable:focus-visible { - border-color: var(--border-subtle); - background: color-mix(in srgb, var(--text-primary) 6%, transparent); - outline: none; -} - - -.notifications-screen .notification-card--clickable:active { - transform: scale(0.99); -} - - - - - - - - -/* Уведомления: информационные блоки без рамок. Hover/focus не возвращает - * обводку — различение сохраняется фоном и лёгкой реакцией на нажатие. */ -.notifications-screen .notifications-list > .notification-card, -.notifications-screen .notifications-list > .notification-card:hover, -.notifications-screen .notifications-list > .notification-card:focus, -.notifications-screen .notifications-list > .notification-card:focus-visible, -.notifications-screen .notifications-list > .notification-card:active { - border: 0; - outline: 0; -} - -.notifications-screen .notifications-list > .notification-empty-state.card, .notifications-screen .notification-empty-state { margin-top: var(--space-5); padding: var(--space-5) var(--space-4); border: 0; background: none; box-shadow: none; text-align: center; justify-items: center; } -.notifications-screen .notification-empty-state strong { font-size: var(--text-md); color: var(--text-primary); } -.notifications-screen .notification-empty-state .meta-muted { max-width: 30ch; font-size: var(--text-sm); } -.notifications-screen .notification-feed-tabs { margin-bottom: var(--space-2); } +.notification-empty-state { margin-top: var(--space-5); padding: var(--space-5) var(--space-4); text-align: center; justify-items: center; } +.notification-empty-state strong { color: var(--text-primary); font-size: var(--text-md); } +.notification-empty-state .meta-muted { max-width: 30ch; font-size: var(--text-sm); } diff --git a/shine-UI/styles/features/preauth.css b/shine-UI/styles/features/preauth.css index 6959dd32..b03e1ce6 100644 --- a/shine-UI/styles/features/preauth.css +++ b/shine-UI/styles/features/preauth.css @@ -49,11 +49,11 @@ .initial-splash__logo-wrap::before { content: ""; position: absolute; - inset: 16%; + /* Сияние гаснет в пределах ~четверти размера знака — не дотягивается до краёв экрана. */ + inset: -14%; z-index: -1; border-radius: 50%; - background: color-mix(in srgb, var(--warning) 20%, transparent); - filter: blur(30px); + background: radial-gradient(closest-side, color-mix(in srgb, var(--warning) 15%, transparent), color-mix(in srgb, var(--warning) 6%, transparent) 55%, transparent); animation: shine-halo-breathe 4.8s ease-in-out infinite; } @@ -66,7 +66,7 @@ filter: drop-shadow(0 0 8px color-mix(in srgb, var(--warning) 72%, transparent)) drop-shadow(0 8px 22px color-mix(in srgb, var(--warning) 38%, transparent)); - animation: shine-logo-breathe 4.8s ease-in-out infinite; + animation: shine-logo-breathe 5.3s ease-in-out infinite; } @@ -83,13 +83,47 @@ .auth-screen--welcome { position: relative; isolation: isolate; - align-content: center; + /* Знак с надписью — у оптического центра, действия — ближе к низу, под большой палец. */ + grid-template-rows: minmax(0, 1fr) auto minmax(0, 1fr); + align-content: stretch; justify-items: center; - gap: clamp(12px, 2.4vh, 20px); - padding-block: 8px; + gap: 0; + padding-block: clamp(var(--space-5), 6vh, 56px) calc(var(--space-5) + env(safe-area-inset-bottom)); font-family: var(--font-main); } +.auth-screen--welcome .auth-logo-wrap { align-self: end; } + +.auth-screen--welcome .shine-actions { + align-self: end; + width: min(100%, 390px); + grid-template-columns: 1fr 1fr; + gap: var(--space-3) var(--space-2); +} + +.auth-screen--welcome .shine-actions > :is(.shine-btn, .secondary-btn) { + grid-column: 1 / -1; + width: 100%; + height: 52px; + min-height: 48px; + border-radius: var(--radius-lg); + font-size: var(--text-lg); + font-weight: var(--weight-bold); +} + +.auth-screen--welcome :is(.start-language-link, .start-settings-link) { + min-height: var(--control-height); + border: 0; + background: transparent; + box-shadow: none; + color: var(--text-secondary); + font-size: var(--text-sm); + font-weight: var(--weight-medium); +} + +.auth-screen--welcome .start-language-link { color: var(--accent); } +.auth-screen--welcome .start-settings-link::after { content: none; } + .screen-content.no-app-chrome:has(> .auth-screen--welcome) { overflow: hidden; @@ -97,29 +131,6 @@ } -.auth-screen--welcome::before { - content: ""; - position: absolute; - inset: -14px -14px calc(-24px - env(safe-area-inset-bottom)); - z-index: -2; - background: - radial-gradient(circle at 50% 18%, color-mix(in srgb, var(--warning) 8%, transparent), transparent 26%), - radial-gradient(circle at 50% 67%, color-mix(in srgb, var(--accent) 6%, transparent), transparent 38%), - var(--background); -} - - -.auth-screen--welcome::after { - content: ""; - position: absolute; - inset: 0; - z-index: -1; - pointer-events: none; - background: linear-gradient(90deg, transparent, color-mix(in srgb, var(--text-primary) 2%, transparent) 50%, transparent); - opacity: 0.7; -} - - .auth-screen--lower { align-content: start; padding-top: clamp(80px, 18vh, 180px); @@ -134,7 +145,7 @@ filter: drop-shadow(0 0 8px color-mix(in srgb, var(--warning) 72%, transparent)) drop-shadow(0 8px 22px color-mix(in srgb, var(--warning) 38%, transparent)); - animation: shine-logo-breathe 4.8s ease-in-out infinite; + animation: shine-logo-breathe 5.3s ease-in-out infinite; } @@ -145,26 +156,60 @@ } -.auth-logo-wrap::before { +/* Сияние знака: два медленно вращающихся навстречу веера широких мазков. Периоды взаимно простые — + мазки то сходятся, то расходятся и почти не повторяются. Эллипс шире по горизонтали, к краям гаснет. */ +.auth-logo-wrap::before, +.auth-logo-wrap::after { + --halo: color-mix(in srgb, var(--warning) 34%, transparent); + --halo-soft: color-mix(in srgb, var(--warning) 15%, transparent); content: ""; position: absolute; - inset: 16%; + /* Спад прозрачности по плавной кривой с длинным хвостом — без видимой границы овала. */ + inset: -80%; z-index: -1; + pointer-events: none; border-radius: 50%; - background: color-mix(in srgb, var(--warning) 20%, transparent); - filter: blur(30px); - animation: shine-halo-breathe 4.8s ease-in-out infinite; + -webkit-mask: radial-gradient(closest-side, #000 12%, rgb(0 0 0 / 0.8) 22%, rgb(0 0 0 / 0.58) 33%, rgb(0 0 0 / 0.4) 44%, rgb(0 0 0 / 0.26) 55%, rgb(0 0 0 / 0.16) 65%, rgb(0 0 0 / 0.09) 75%, rgb(0 0 0 / 0.045) 84%, rgb(0 0 0 / 0.018) 92%, transparent); + mask: radial-gradient(closest-side, #000 12%, rgb(0 0 0 / 0.8) 22%, rgb(0 0 0 / 0.58) 33%, rgb(0 0 0 / 0.4) 44%, rgb(0 0 0 / 0.26) 55%, rgb(0 0 0 / 0.16) 65%, rgb(0 0 0 / 0.09) 75%, rgb(0 0 0 / 0.045) 84%, rgb(0 0 0 / 0.018) 92%, transparent); + filter: blur(24px); +} + +.auth-logo-wrap::before { + background: conic-gradient(from 0deg, var(--halo) 0deg, transparent 58deg, var(--halo-soft) 104deg, transparent 150deg, var(--halo) 212deg, var(--halo-soft) 250deg, transparent 296deg, var(--halo) 360deg); + transform: scaleY(0.5); + animation: shine-halo-spin 83s linear infinite, shine-halo-breathe 7.3s ease-in-out infinite; + animation-delay: var(--halo-phase-1, 0s), var(--halo-phase-2, 0s); +} + +.auth-logo-wrap::after { + --halo: color-mix(in srgb, color-mix(in srgb, var(--warning) 82%, var(--accent)) 28%, transparent); + background: conic-gradient(from 40deg, transparent 0deg, var(--halo) 36deg, transparent 92deg, var(--halo-soft) 140deg, transparent 176deg, var(--halo) 238deg, transparent 290deg, var(--halo-soft) 322deg, transparent 360deg); + transform: scaleY(0.5); + animation: shine-halo-spin 127s linear infinite reverse, shine-halo-breathe 11.9s ease-in-out infinite; + animation-delay: var(--halo-phase-3, 0s), var(--halo-phase-4, -4s); +} + +/* На светлом фоне золото темнеет в коричневый — сияние тише. */ +:root[data-theme='light'] .auth-logo-wrap::before, +:root[data-theme='light'] .auth-logo-wrap::after { + --halo: color-mix(in srgb, var(--warning) 18%, transparent); + --halo-soft: color-mix(in srgb, var(--warning) 8%, transparent); } .auth-brand { - margin: -4px 0 clamp(4px, 1vh, 10px); + margin: clamp(20px, 3.4vh, 32px) 0 0; color: var(--text-primary); font-size: clamp(42px, 9vw, 56px); - font-weight: 500; line-height: 1; - letter-spacing: 0; - text-shadow: 0 3px 22px color-mix(in srgb, var(--warning) 20%, transparent); +} + + +.auth-brand .shine-wordmark { + display: block; + width: auto; + height: 0.5em; + overflow: visible; } @@ -206,14 +251,12 @@ } - .shine-btn:disabled { opacity: 0.45; cursor: not-allowed; } - .shine-local-demo-btn { min-height: 32px; padding: 5px 12px; @@ -245,8 +288,15 @@ @keyframes shine-halo-breathe { - 0%, 100% { opacity: 0.66; transform: scale(0.96); } - 50% { opacity: 1; transform: scale(1.05); } + 0%, 100% { opacity: 0.55; } + 50% { opacity: 1; } +} + + +/* Сначала поворот, потом сплющивание: эллипс всегда лежит горизонтально и не тянется к верхнему краю. */ +@keyframes shine-halo-spin { + from { transform: scaleY(0.5) rotate(0deg); } + to { transform: scaleY(0.5) rotate(360deg); } } @@ -265,16 +315,9 @@ .initial-splash__brand { font-size: 40px; } -.auth-screen--welcome { - gap: 10px; - } .auth-logo-wrap { width: 206px; } -.auth-brand { - font-size: 40px; - margin-bottom: 2px; - } .shine-actions { gap: 10px; } @@ -292,6 +335,7 @@ .initial-splash__logo-wrap::before, .auth-logo, .auth-logo-wrap::before, +.auth-logo-wrap::after, .shine-btn { animation: none; transition: none; @@ -456,7 +500,6 @@ .screen-content.preauth-flow:not(:has(> .auth-screen--welcome)) .field-label, .screen-content.preauth-flow:not(:has(> .auth-screen--welcome)) .auth-copy, -.screen-content.preauth-flow:not(:has(> .auth-screen--welcome)) .status-line, .screen-content.preauth-flow:not(:has(> .auth-screen--welcome)) .registration-word-number { color: var(--preauth-muted); } @@ -516,11 +559,6 @@ } -.screen-content.preauth-flow:not(:has(> .auth-screen--welcome)) .preauth-local-demo-btn { - min-height: 44px; -} - - .screen-content.preauth-flow:not(:has(> .auth-screen--welcome)) .registration-toggle, .screen-content.preauth-flow:not(:has(> .auth-screen--welcome)) .session-item { border-color: var(--preauth-line); @@ -554,11 +592,6 @@ } -.screen-content.preauth-flow:not(:has(> .auth-screen--welcome)) .registration-screen { - gap: 12px; -} - - .screen-content.preauth-flow:not(:has(> .auth-screen--welcome)) .registration-form { gap: 14px; padding: 16px; @@ -592,10 +625,19 @@ .registration-login-status { + display: block; + min-height: var(--leading-sm); margin: 0; - font-size: 13px; + font-size: var(--text-sm); + line-height: var(--leading-sm); + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; } +.registration-login-status.is-available::before { content: "✓ "; } +.registration-login-status.is-checking { color: var(--text-secondary); } + .registration-faq-link { justify-self: center; @@ -607,8 +649,6 @@ } - - @media (max-width: 360px) { .screen-content.preauth-flow:not(:has(> .auth-screen--welcome)) { padding-inline: 12px; @@ -626,11 +666,6 @@ } -.login-panel--wide { - width: min(100%, 420px); -} - - .login-panel-title { font-size: 28px; font-weight: 700; @@ -807,12 +842,35 @@ } +/* Глаз — внутри поля пароля, у правого края. */ +.registration-password-single .inline-input-row { + position: relative; + display: block; +} + +.registration-password-single .inline-input-row .input { + width: 100%; + padding-right: 48px; +} + .registration-password-toggle { + position: absolute; + top: 50%; + right: 2px; width: 44px; height: 44px; min-width: 44px; min-height: 44px; - border-radius: 14px; + border: 0; + border-radius: var(--radius-md); + background: transparent; + color: var(--text-secondary); + transform: translateY(-50%); +} + +.registration-password-toggle .key-toggle-icon { + width: 20px; + height: 20px; } @@ -833,7 +891,6 @@ } - /* Новый двухшаговый login flow */ .login-remote-server { width: 100%; @@ -854,11 +911,6 @@ } -.login-device-preparation { - width: 100%; -} - - .secret-generation-overlay { position: fixed; inset: 0; @@ -912,58 +964,302 @@ } -/* ===== Вход через другое устройство: заголовок внутри панели ===== */ -.auth-screen--other-device { - justify-content: flex-start; - padding-top: max(18px, env(safe-area-inset-top)); +/* Сохранение ключей: заголовок-итог, список с переключателями, короткий совет. */ +.keys-lead { display: grid; gap: var(--space-1); padding: var(--space-2) var(--space-1) 0; } +.keys-lead__title { margin: 0; color: var(--text-primary); font-size: var(--text-xl); line-height: var(--leading-xl); font-weight: var(--weight-bold); } +.keys-lead__text { margin: 0; color: var(--text-secondary); font-size: var(--text-md); line-height: var(--leading-md); text-wrap: pretty; } +.keys-lead__text + .keys-lead__text { margin-top: calc(-1 * var(--space-1)); } + +.keys-list { + display: grid; + border: 1px solid var(--border-subtle); + border-radius: var(--radius-lg); + background: var(--surface); + overflow: hidden; } - -.auth-screen--other-device .login-panel { - margin-top: 0; -} - - -.login-panel-inline-back { - width: 100%; - min-height: 42px; +.keys-row { display: flex; align-items: center; - justify-content: flex-start; - gap: 10px; - padding: 0 2px; - font-size: 18px; - font-weight: 700; - text-align: left; + gap: var(--space-3); + min-height: 64px; + padding: var(--space-3) var(--space-4); + cursor: pointer; +} + +.keys-row + .keys-row { border-top: 1px solid var(--border-subtle); } +.keys-row:has(.switch:disabled) { cursor: default; } +.keys-row__text { display: grid; gap: 2px; flex: 1 1 auto; min-width: 0; } +.keys-row__title { color: var(--text-primary); font-size: var(--text-md); line-height: var(--leading-md); font-weight: var(--weight-medium); } +.keys-row__hint { color: var(--text-secondary); font-size: var(--text-sm); line-height: var(--leading-sm); text-wrap: pretty; } + +.keys-note { margin: 0; padding: 0 var(--space-1); color: var(--text-secondary); font-size: var(--text-sm); line-height: var(--leading-sm); } +.keys-actions { display: grid; gap: var(--space-2); margin-top: var(--space-2); } + + +/* Оплата регистрации: «обновить баланс» — второстепенная кнопка-иконка, пока грузится — крутится. */ +.payment-refresh-btn { + display: grid; + place-items: center; + width: 44px; + min-width: 44px; + height: 44px; + padding: 0; + border: 1px solid var(--border-control); + border-radius: var(--radius-md); + background: transparent; + color: var(--action); +} + +.payment-refresh-btn svg { width: 22px; height: 22px; } +.payment-refresh-btn.is-loading:disabled { opacity: 1; cursor: progress; } +.payment-refresh-btn.is-loading svg { animation: secret-generation-spin 0.9s linear infinite; } + +@media (prefers-reduced-motion: reduce) { + .payment-refresh-btn.is-loading svg { animation: none; } } -.login-panel-inline-back > span:first-child { - font-size: 24px; - line-height: 1; +/* ===== Вход с другого устройства: код, таймер, шаги ===== */ +.pairing-who { + margin: 0; + color: var(--text-secondary); + font-size: var(--text-md); + text-align: center; } +.pairing-code-block { display: grid; gap: var(--space-4); } +.pairing-code-block[hidden] { display: none; } + +.pairing-code-card { + display: grid; + justify-items: center; + gap: var(--space-3); + padding: var(--space-5) var(--space-4) var(--space-4); + border: 1px solid var(--border-subtle); + border-radius: var(--radius-lg); + background: var(--surface); +} + +.pairing-code-card__label { + margin: 0; + color: var(--text-secondary); + font-size: var(--text-sm); +} + +.pairing-code { + color: var(--text-primary); + font-size: clamp(30px, 9vw, 38px); + font-weight: 600; + font-variant-numeric: tabular-nums; + letter-spacing: 0.06em; + line-height: 1.1; + white-space: nowrap; + user-select: all; +} + +.pairing-timer { + display: grid; + grid-template-columns: minmax(0, 1fr) auto; + align-items: center; + gap: var(--space-3); + width: min(100%, 260px); +} + +.pairing-timer__bar { + height: 4px; + border-radius: var(--radius-pill); + background: var(--surface-raised); + overflow: hidden; +} + +.pairing-timer__bar > span { + display: block; + height: 100%; + border-radius: inherit; + background: var(--accent); + transition: width 1s linear; +} + +.pairing-timer__text { + min-width: 3.2em; + color: var(--text-secondary); + font-size: var(--text-sm); + font-variant-numeric: tabular-nums; + text-align: right; +} + +.pairing-online { + margin: 0; + color: var(--text-secondary); + font-size: var(--text-sm); +} + +.pairing-online.is-online { color: var(--success); } +.pairing-online.is-online::before { content: "● "; } + +.pairing-steps { + display: grid; + gap: var(--space-2); + margin: 0; + padding: 0 var(--space-2); + list-style: none; + counter-reset: pairing-step; +} + +.pairing-steps > li { + display: grid; + grid-template-columns: 24px minmax(0, 1fr); + align-items: center; + gap: var(--space-3); + color: var(--text-primary); + font-size: var(--text-md); + line-height: var(--leading-md); + text-wrap: pretty; + counter-increment: pairing-step; +} + +.pairing-steps > li::before { + content: counter(pairing-step); + display: grid; + place-items: center; + width: 24px; + height: 24px; + border-radius: 50%; + background: var(--surface-selected); + color: var(--action); + font-size: var(--text-xs); + font-weight: var(--weight-bold); +} + +.pairing-waiting, +.pairing-notice { + display: flex; + align-items: center; + justify-content: center; + gap: var(--space-2); + margin: 0; + color: var(--text-secondary); + font-size: var(--text-sm); + text-align: center; +} + +.pairing-notice[hidden] { display: none; } +.pairing-notice > p { margin: 0; text-wrap: balance; } + +.pairing-notice.is-error { + padding: var(--space-4); + border: 1px solid color-mix(in srgb, var(--danger) 35%, transparent); + border-radius: var(--radius-lg); + background: color-mix(in srgb, var(--danger) 10%, transparent); + color: var(--danger); + font-size: var(--text-md); +} + +.pairing-spinner { + flex: 0 0 auto; + width: 14px; + height: 14px; + border: 2px solid var(--border-control); + border-top-color: var(--accent); + border-radius: 50%; + animation: secret-generation-spin 0.9s linear infinite; +} + +.pairing-spinner[hidden], +.pairing-password[hidden], +.pairing-login > .primary-btn[hidden] { display: none; } + +/* Узкие экраны: шаги остаются в одну строку. */ +@media (max-width: 360px) { + .pairing-steps > li { font-size: var(--text-sm); } +} + +@media (prefers-reduced-motion: reduce) { + .pairing-spinner { animation: none; } + .pairing-timer__bar > span { transition: none; } +} /* ===== UX refinements 2026-08-29 ===== */ -/* Start: larger breathing room between brand and actions. */ -.auth-screen--welcome .auth-brand { - margin-bottom: clamp(34px, 6vh, 58px); + + +/* Настройки входа: все серверы в одной карточке, статус — пилюля справа от подписи (она же «проверить ещё раз»). */ +.entry-servers { + display: grid; + border: 1px solid var(--border-subtle); + border-radius: var(--radius-lg); + background: var(--surface); } -.auth-screen--welcome .shine-actions { - margin-top: 0; +.entry-server { + display: grid; + gap: var(--space-2); + padding: var(--space-3) var(--space-4) var(--space-4); } +.entry-server + .entry-server { border-top: 1px solid var(--border-subtle); } -/* Entry settings actions use the existing Start button visual language without huge width side effects. */ -.screen-content.preauth-flow .server-check-btn.shine-btn { - width: auto; - height: 44px; - min-height: 44px; - padding-inline: 18px; - border-radius: 14px; - font-size: 15px; +.entry-server__head { + display: flex; + align-items: center; + justify-content: space-between; + gap: var(--space-2); +} + +.entry-server__hint { + margin: calc(-1 * var(--space-1)) 0 0; + color: var(--text-secondary); + font-size: var(--text-xs); + line-height: var(--leading-xs); + overflow-wrap: anywhere; +} + +.entry-status { + display: inline-flex; + align-items: center; + gap: 6px; + min-height: 32px; + padding: 0 var(--space-3); + border: 0; + border-radius: var(--radius-pill); + background: color-mix(in srgb, var(--action) 14%, transparent); + color: var(--action); + font-size: var(--text-sm); + font-weight: var(--weight-medium); + white-space: nowrap; +} + +.entry-status:is(.is-available, .is-unavailable)::before { + content: ""; + width: 7px; + height: 7px; + border-radius: 50%; + background: currentColor; +} + +.entry-status.is-available { + color: var(--success); + background: color-mix(in srgb, var(--success) 15%, transparent); +} + +.entry-status.is-unavailable { + color: var(--danger); + background: color-mix(in srgb, var(--danger) 15%, transparent); +} + +.entry-status.is-checking:disabled { + opacity: 1; + cursor: progress; + color: var(--text-secondary); + background: transparent; +} + +.entry-settings__actions { + display: grid; + gap: var(--space-2); + width: 100%; + margin-top: var(--space-2); } .screen-content.preauth-flow .auth-footer-actions .shine-btn { @@ -994,19 +1290,6 @@ } .screen-content.preauth-flow .topbar { background: transparent; } -.auth-screen--welcome .shine-actions { gap: var(--space-3); } -.auth-screen--welcome .start-language-link, -.auth-screen--welcome .start-settings-link { - min-height: var(--control-height); - border: 0; - background: transparent; - box-shadow: none; - color: var(--accent); - font-size: var(--text-md); - font-weight: var(--weight-medium); -} -.auth-screen--welcome .start-settings-link { color: var(--text-secondary); font-size: var(--text-sm); } -.auth-screen--welcome .start-settings-link::after { content: none; } .screen-content.preauth-flow:not(:has(> .auth-screen--welcome)) .login-choice-screen .topbar { margin-bottom: var(--space-4); } .screen-content.preauth-flow:not(:has(> .auth-screen--welcome)) .login-choice-screen .topbar__title { display: block; } @@ -1025,7 +1308,6 @@ text-underline-offset: 3px; } -.screen-content.preauth-flow:not(:has(> .auth-screen--welcome)) .topbar { min-height: 56px; margin-bottom: var(--space-2); grid-template-columns: 44px minmax(0, 1fr) 44px; } +.screen-content.preauth-flow:not(:has(> .auth-screen--welcome)) .topbar { min-height: 56px; margin-bottom: calc(var(--page-top-gap) - 10px); /* + промежуток .stack 10px */ grid-template-columns: 44px minmax(0, 1fr) 44px; } + -.auth-screen--welcome .shine-actions { width: min(100%, 420px); justify-self: center; } -.auth-screen--welcome .shine-actions > :is(.shine-btn, .secondary-btn) { width: 100%; min-height: 48px; font-size: var(--text-md); font-weight: var(--weight-bold); } diff --git a/shine-UI/styles/features/profile-page.css b/shine-UI/styles/features/profile-page.css index 3fe71187..7d54b303 100644 --- a/shine-UI/styles/features/profile-page.css +++ b/shine-UI/styles/features/profile-page.css @@ -1,51 +1,81 @@ /* Карточка профиля (js/components/profile-card.js): свой и чужой профиль в одной системе с «О канале». * Селекторы привязаны к .user-profile-screen, чтобы перекрыть старую геометрию profile.css. */ -.user-profile-screen { gap: 0; min-height: 0; overflow-x: hidden; } +.user-profile-screen { gap: 0; min-height: 0; overflow-x: clip; } .user-profile-screen::before { content: none; } .user-profile-screen .user-profile-body { display: grid; gap: var(--space-4); padding: var(--space-2) 0 var(--space-5); } .user-profile-screen .user-profile-status:empty { display: none; } .user-profile-screen .pf-hero { display: grid; justify-items: center; gap: var(--space-1); text-align: center; } -.user-profile-screen .pf-avatar { position: relative; grid-column: auto; grid-row: auto; width: 96px; height: 96px; margin-bottom: var(--space-2); display: grid; place-items: center; justify-self: center; } +.user-profile-screen .pf-identity { + width: min(100%, 420px); + display: grid; + grid-template-columns: minmax(72px, 1fr) 96px minmax(72px, 1fr); + align-items: center; + gap: 10px; +} +.user-profile-screen .pf-status-card-slot { min-width: 0; display: grid; align-items: center; } +.user-profile-screen .pf-status-card-slot--left { justify-items: end; } +.user-profile-screen .pf-status-card-slot--right { justify-items: start; } +.user-profile-screen .pf-status-card { + width: min(100%, 106px); + aspect-ratio: 1; + display: grid; + grid-template-rows: auto minmax(0, 1fr) minmax(0, 1fr); + border: 1px solid var(--border-subtle); + border-radius: var(--radius-lg); + background: var(--surface); + overflow: hidden; +} +.user-profile-screen .pf-status-card--primary { border-color: color-mix(in srgb, var(--rel-family) 55%, var(--border-subtle)); } +.user-profile-screen .pf-status-card--shine { border-color: color-mix(in srgb, var(--rel-shining) 55%, var(--border-subtle)); } +.user-profile-screen .pf-status-card-title { + min-height: 27px; + padding: 7px 5px 5px; + display: grid; + place-items: center; + color: var(--text-primary); + font-size: 11px; + line-height: 1.1; + font-weight: var(--weight-bold); +} +.user-profile-screen .pf-status-card-count { + min-width: 0; + padding: 3px 2px; + display: grid; + place-items: center; + align-content: center; + gap: 0; + border: 0; + border-top: 1px solid var(--border-subtle); + background: transparent; + color: var(--text-primary); + font: inherit; + cursor: pointer; +} +.user-profile-screen .pf-status-card-count:hover, +.user-profile-screen .pf-status-card-count:active { background: var(--surface-selected); } +.user-profile-screen .pf-status-card-count:focus-visible { outline: 2px solid var(--focus-ring); outline-offset: -2px; } +.user-profile-screen .pf-status-card-count strong { font-size: var(--text-md); line-height: 1.05; font-weight: var(--weight-bold); } +.user-profile-screen .pf-status-card-count span { color: var(--text-secondary); font-size: 9px; line-height: 1.05; } +.user-profile-screen .pf-avatar { position: relative; width: 96px; height: 96px; display: grid; place-items: center; justify-self: center; } .user-profile-screen .pf-avatar .user-profile-hero-avatar.avatar, .user-profile-screen .pf-avatar .user-profile-hero-avatar.avatar-image { width: 96px; height: 96px; min-width: 96px; min-height: 96px; font-size: 36px; } .user-profile-screen .pf-avatar .user-profile-hero-avatar.avatar-framed > .avatar-fallback, .user-profile-screen .pf-avatar .user-profile-hero-avatar.avatar-framed > .avatar-photo { width: 100%; height: 100%; } .user-profile-screen .pf-avatar .user-profile-hero-avatar.avatar-framed::after, .user-profile-screen .pf-avatar .user-profile-hero-avatar.avatar-glow::before { content: none; } -.user-profile-screen .pf-hero.is-shining .pf-avatar::after { - content: ''; - position: absolute; - inset: -5px; - border-radius: 50%; - border: 2px solid var(--rel-shining); - box-shadow: 0 0 14px var(--rel-shining-glow); - pointer-events: none; -} -.user-profile-screen .pf-name { margin: 0; color: var(--text-primary); font-size: var(--text-xl); line-height: var(--leading-xl); font-weight: var(--weight-bold); overflow-wrap: anywhere; } +.user-profile-screen .pf-name { margin: var(--space-2) 0 0; color: var(--text-primary); font-size: var(--text-xl); line-height: var(--leading-xl); font-weight: var(--weight-bold); overflow-wrap: anywhere; } .user-profile-screen .pf-login { color: var(--text-secondary); font-size: var(--text-sm); line-height: var(--leading-sm); } -.user-profile-screen .pf-statuses { display: flex; flex-wrap: wrap; justify-content: center; gap: var(--space-2); margin-top: var(--space-2); } -.user-profile-screen .pf-status { - min-height: 32px; - padding: 0 12px; - display: inline-flex; - align-items: center; - gap: 6px; - border: 1px solid var(--border-subtle); - border-radius: var(--radius-pill); - color: var(--text-secondary); - background: var(--surface); - font: inherit; - font-size: var(--text-xs); - cursor: pointer; +@media (max-width: 360px) { + .user-profile-screen .pf-identity { grid-template-columns: minmax(66px, 1fr) 88px minmax(66px, 1fr); gap: 7px; } + .user-profile-screen .pf-avatar, + .user-profile-screen .pf-avatar .user-profile-hero-avatar.avatar, + .user-profile-screen .pf-avatar .user-profile-hero-avatar.avatar-image { width: 88px; height: 88px; min-width: 88px; min-height: 88px; } + .user-profile-screen .pf-status-card { width: min(100%, 96px); } + .user-profile-screen .pf-status-card-title { font-size: 10px; } + .user-profile-screen .pf-status-card-count span { font-size: 8px; } } -.user-profile-screen .pf-status b { color: var(--text-primary); font-weight: var(--weight-bold); } -.user-profile-screen .pf-status-dot { width: 7px; height: 7px; border-radius: 50%; background: var(--border-control); } -.user-profile-screen .pf-status.is-active { color: var(--text-primary); border-color: var(--border-control); } -.user-profile-screen .pf-status.is-active .pf-status-dot { background: var(--rel-shining); box-shadow: 0 0 6px var(--rel-shining-glow); } -.user-profile-screen .pf-status[data-profile-list='primary_received'].is-active .pf-status-dot { background: var(--rel-family); box-shadow: 0 0 6px var(--rel-family-glow); } -.user-profile-screen .pf-status:focus-visible { outline: 2px solid var(--focus-ring); outline-offset: 2px; } .user-profile-screen .pf-stats { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); border: 1px solid var(--border-subtle); border-radius: var(--radius-lg); background: var(--surface); overflow: hidden; } .user-profile-screen .pf-stat { min-height: 64px; padding: var(--space-2) var(--space-1); display: grid; align-content: center; justify-items: center; gap: 2px; border: 0; border-left: 1px solid var(--border-subtle); background: transparent; color: var(--text-primary); font: inherit; cursor: pointer; } @@ -109,3 +139,35 @@ .profiles-active-badge { padding: 2px 8px; border-radius: var(--radius-pill); color: var(--accent); background: var(--accent-soft); font-size: .6875rem; font-weight: var(--weight-bold); } .screen-content .profiles-row .profiles-close { width: 44px; height: 44px; display: grid; place-items: center; border: 0; border-radius: var(--radius-md); color: var(--text-secondary); background: transparent; font-size: 22px; cursor: pointer; } .screen-content .profiles-row .profiles-close:hover { background: var(--surface-selected); color: var(--danger); } + +/* Экран управления отношениями с другим пользователем. */ +.relation-manage-screen { gap: var(--space-3); } +.relation-manage-status:empty { display: none; } +.relation-manage-body { gap: var(--space-3); } +.relation-manage-body.is-busy { opacity: .72; pointer-events: none; } +.relation-manage-card { gap: var(--space-3); } +.relation-manage-card-head { display: grid; gap: 2px; } +.relation-manage-card-head > strong { color: var(--text-primary); font-size: var(--text-md); } +.relation-manage-card-head > span { color: var(--text-secondary); font-size: var(--text-xs); } +.relation-manage-current { display: grid; border: 1px solid var(--border-subtle); border-radius: var(--radius-md); overflow: hidden; } +.relation-manage-current-row { min-height: 48px; padding: 8px 12px; display: flex; align-items: center; justify-content: space-between; gap: var(--space-3); border-top: 1px solid var(--border-subtle); } +.relation-manage-current-row:first-child { border-top: 0; } +.relation-manage-current-row > span { color: var(--text-secondary); font-size: var(--text-sm); } +.relation-manage-current-row > strong { color: var(--text-primary); font-size: var(--text-sm); text-align: right; } +.relation-manage-mutual { min-height: 52px; padding: 10px 12px; display: flex; align-items: center; justify-content: center; gap: 5px; border: 1px solid var(--border-subtle); border-radius: var(--radius-md); background: var(--surface-selected); } +.relation-manage-mutual-label { color: var(--text-secondary); } +.relation-manage-mutual > strong { color: var(--text-primary); } +.relation-manage-choices { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: var(--space-2); } +.relation-manage-choice { width: 100%; min-width: 0; } +.relation-manage-choice.is-active { background: var(--surface-selected); border-color: var(--accent); color: var(--accent); } +.relation-manage-confirmations { display: grid; gap: 6px; } +.relation-manage-confirmations:empty { display: none; } +.relation-manage-confirmation { padding: 9px 11px; border-radius: var(--radius-md); background: var(--surface-selected); color: var(--text-primary); font-size: var(--text-sm); line-height: var(--leading-sm); } +.relation-manage-confirm-btn { width: 100%; } +.relation-manage-card--official { border-color: color-mix(in srgb, var(--rel-family) 45%, var(--border-subtle)); } +.relation-manage-card--shine { border-color: color-mix(in srgb, var(--rel-shining) 45%, var(--border-subtle)); } + +@media (max-width: 420px) { + .relation-manage-choices { grid-template-columns: 1fr; } + .relation-manage-current-row { align-items: flex-start; } +} diff --git a/shine-UI/styles/features/settings.css b/shine-UI/styles/features/settings.css index 5127bb6a..d8cb3fc4 100644 --- a/shine-UI/styles/features/settings.css +++ b/shine-UI/styles/features/settings.css @@ -142,15 +142,25 @@ } -.screen-content.settings-bordered-actions :is(.secondary-btn, .ghost-btn, .text-btn, .shine-btn, .settings-bordered-btn, .profile-relative-suggest-item) { +/* Второстепенные действия – та же роль, что во всём приложении: прозрачная кнопка, рамка, цвет «действия». */ +.screen-content.settings-bordered-actions .profile-relative-suggest-item { min-height: var(--control-height); padding-inline: 14px; border: 1px solid var(--border-subtle); border-radius: var(--radius-md); background: var(--surface); - box-shadow: none; color: var(--text-primary); font-size: var(--text-md); +} +.screen-content.settings-bordered-actions :is(.secondary-btn, .ghost-btn, .text-btn, .shine-btn, .settings-bordered-btn) { + min-height: var(--control-height); + padding-inline: 14px; + border: 1px solid var(--border-control); + border-radius: var(--radius-md); + background: transparent; + box-shadow: none; + color: var(--action); + font-size: var(--text-md); font-weight: var(--weight-medium); text-shadow: none; backdrop-filter: none; @@ -171,9 +181,9 @@ font-size: var(--text-md); font-weight: var(--weight-medium); min-height: var(--control-height); - border: 1px solid var(--border-subtle); + border: 1px solid var(--border-control); border-radius: var(--radius-md); - background: var(--surface); + background: transparent; color: var(--danger); box-shadow: none; } @@ -276,45 +286,6 @@ .language-choice-actions .shine-btn { height: 50px; } /* ===== Скрытые расширенные настройки ===== */ -.settings-shine-logo-button { - width: min(72vw, 280px); - min-height: 118px; - margin: 2px auto 10px; - padding: 6px 12px; - display: grid; - place-items: center; - border: 0; - background: transparent; - box-shadow: none; - cursor: pointer; - -webkit-tap-highlight-color: transparent; - user-select: none; -} - -.settings-shine-logo-button:hover, -.settings-shine-logo-button:focus, -.settings-shine-logo-button:active { - border: 0; - background: transparent; - box-shadow: none; - transform: none; -} - -.settings-shine-logo-button:focus-visible { - outline: 2px solid color-mix(in srgb, var(--accent) 70%, transparent); - outline-offset: 4px; - border-radius: 22px; -} - -.settings-shine-logo { - display: block; - width: 100%; - max-height: 126px; - object-fit: contain; - pointer-events: none; - filter: drop-shadow(0 12px 30px color-mix(in srgb, var(--accent) 16%, transparent)); -} - .settings-feature-toggle-row { min-height: 76px; padding: 15px 16px; @@ -343,52 +314,170 @@ color: var(--text-secondary); } -.settings-feature-switch { - appearance: none; - -webkit-appearance: none; - flex: 0 0 auto; - width: 48px; - height: 28px; - margin: 0; - padding: 2px; - border: 1px solid var(--border-control); - border-radius: var(--radius-pill); - background: var(--surface-selected); - cursor: pointer; - transition: background-color var(--duration-fast) ease, border-color var(--duration-fast) ease; -} - -.settings-feature-switch::after { - content: ''; - display: block; - width: 22px; - height: 22px; - border-radius: 50%; - background: var(--text-secondary); - box-shadow: var(--shadow-sm); - transition: transform var(--duration-fast) ease, background-color var(--duration-fast) ease; -} - -.settings-feature-switch:checked { - border-color: var(--accent); - background: var(--accent); -} - -.settings-feature-switch:checked::after { - transform: translateX(20px); - background: var(--on-accent); -} - -.settings-feature-switch:focus-visible { - outline: 2px solid color-mix(in srgb, var(--accent) 82%, transparent); - outline-offset: 3px; -} - -.settings-shine-logo-button { justify-self: center; } -.settings-shine-logo { width: 48px; height: 48px; max-height: 48px; object-fit: contain; } -.settings-shine-logo-button { min-height: 0; padding: 0; margin: 0 auto; } .settings-sections { gap: var(--space-4); } .settings-theme-card { gap: var(--space-2); } .settings-theme-editor { width: 100%; } .settings-intro { padding-top: var(--space-3); } .settings-intro > p { margin: 0; padding-inline: var(--space-1); font-size: var(--text-sm); line-height: var(--leading-sm); } + +/* ===== Мой блокчейн ===== */ +.my-blockchain-list { + gap: 7px; +} + +.my-blockchain-entry { + display: grid; + gap: 0; + padding: 10px 12px; +} + +.my-blockchain-entry__head { + min-width: 0; + display: grid; + grid-template-columns: minmax(0, 1fr) 30px; + align-items: center; + gap: 8px; +} + +.my-blockchain-entry__copy { + min-width: 0; + display: grid; + gap: 3px; +} + +.my-blockchain-entry__title { + min-width: 0; + overflow: hidden; + color: var(--text-primary); + font-size: 14px; + font-weight: 650; + line-height: 1.35; + text-overflow: ellipsis; + white-space: nowrap; +} + +.my-blockchain-entry__meta { + min-width: 0; + overflow: hidden; + font-size: 11px; + line-height: 1.3; + text-overflow: ellipsis; + white-space: nowrap; +} + +.my-blockchain-entry__toggle { + width: 30px; + height: 30px; + min-height: 30px; + padding: 0; + display: grid; + place-items: center; + border-radius: 50%; +} + +.my-blockchain-entry__toggle:hover { + background: var(--surface-selected); +} + +.my-blockchain-entry__triangle { + width: 0; + height: 0; + border-left: 5px solid transparent; + border-right: 5px solid transparent; + border-top: 7px solid currentColor; + transform-origin: 50% 45%; + transition: transform 140ms ease; +} + +.my-blockchain-entry__toggle[aria-expanded="true"] .my-blockchain-entry__triangle { + transform: rotate(180deg); +} + +.my-blockchain-entry__details { + min-width: 0; + margin-top: 10px; + padding-top: 10px; + border-top: 1px solid var(--border-subtle); +} + +.my-blockchain-entry__details[hidden] { + display: none; +} + +.my-blockchain-entry__detail-title { + display: block; + margin-bottom: 7px; + font-size: 14px; + line-height: 1.4; +} + +.my-blockchain-entry__full-text { + max-height: 45vh; + overflow: auto; + margin-bottom: 8px; + padding: 9px 10px; + border-radius: var(--radius-sm); + background: color-mix(in srgb, var(--text-primary) 4%, transparent); + font-size: 13px; + line-height: 1.5; + overflow-wrap: anywhere; + white-space: pre-wrap; +} + +.my-blockchain-entry__attachments { + margin-bottom: 7px; + font-size: 12px; +} + +.my-blockchain-entry__actions { + display: flex; + flex-wrap: wrap; + align-items: center; + gap: 6px 14px; + margin: 2px 0 9px; +} + +.my-blockchain-entry__action { + min-height: 30px; + padding: 4px 0; + color: var(--action); + font-size: 13px; + font-weight: 600; + text-decoration: none; +} + +.my-blockchain-entry__external:hover { + text-decoration: underline; +} + +.my-blockchain-entry__detail-grid { + display: grid; + gap: 4px; +} + +.my-blockchain-entry__detail-row { + min-width: 0; + display: grid; + grid-template-columns: minmax(92px, 0.32fr) minmax(0, 1fr); + gap: 8px; + align-items: start; + font-size: 11px; + line-height: 1.4; +} + +.my-blockchain-entry__detail-key { + color: var(--text-secondary); +} + +.my-blockchain-entry__detail-value { + min-width: 0; + color: var(--text-primary); + overflow-wrap: anywhere; + word-break: break-word; +} + +@media (max-width: 520px) { + .my-blockchain-entry__detail-row { + grid-template-columns: 84px minmax(0, 1fr); + } +} diff --git a/shine-UI/styles/main.css b/shine-UI/styles/main.css index 0ddf72a4..a31ef04d 100644 --- a/shine-UI/styles/main.css +++ b/shine-UI/styles/main.css @@ -1,19 +1,32 @@ :root { - --background: #12141f; - --surface: #1c2031; - --surface-selected: #272c45; - --text-primary: #eceefa; - --text-secondary: #a0a6c2; - --border-subtle: #343a55; - --border-control: #6d7396; - --accent: #a9b4ff; - --on-accent: #151a3d; - --focus-ring: #a9b4ff; - --reaction-active: #ff9bb3; - --danger: #ffa7a3; - --success: #8fdab4; - --warning: #e8c585; - --scrim: #00000099; + /* Палитра по умолчанию — «Сияние» (js/services/theme-service.js, пресет aurora) */ + --background: #121419; + --surface: #1c1f27; + --surface-selected: #302b43; + --surface-raised: #272a34; + --text-primary: #f1f1f5; + --text-secondary: #a8abb8; + --border-subtle: #303440; + --border-control: #454858; + --accent: #b8aef5; + --on-accent: #211c34; + --action: #c6bff5; + --bubble-out: #39324d; + --focus-ring: #b8aef5; + --reaction-active: #b8aef5; + --danger: #f2a1ad; + --success: #91d4b0; + --warning: #edc487; + --info: #a8c9f3; + --scrim: #06080cb3; + /* Производные состояния: считаются от ролей, поэтому работают с любой палитрой */ + --accent-hover: color-mix(in srgb, var(--accent) 86%, var(--text-primary)); + --accent-pressed: color-mix(in srgb, var(--accent) 88%, var(--background)); + --disabled-bg: color-mix(in srgb, var(--surface-raised) 80%, var(--background)); + --disabled-text: color-mix(in srgb, var(--text-secondary) 72%, var(--background)); + --quote-bg: color-mix(in srgb, var(--background) 70%, var(--surface)); + --quote-line: color-mix(in srgb, var(--accent) 55%, var(--text-secondary)); + --divider-soft: color-mix(in srgb, var(--border-subtle) 70%, var(--background)); /* Язык связей: один цвет — один тип отношения во всём приложении (граф, личные, профиль). */ --rel-contact: #8c63ff; /* обычная связь / контакт */ --rel-family: #f0b82e; /* семья / близкий круг */ @@ -48,6 +61,8 @@ --space-5: 24px; --space-6: 32px; --page-gutter: var(--space-4); + /* Зазор между шапкой и первым элементом экрана – один на всё приложение. */ + --page-top-gap: var(--space-3); /* Скругления */ --radius-xs: 8px; --radius-sm: 10px; @@ -80,21 +95,25 @@ } :root[data-theme='light'] { - --background: #eef0f5; + --background: #f3f2f7; --surface: #ffffff; - --surface-selected: #dde3f5; - --text-primary: #1e2233; - --text-secondary: #5c6279; - --border-subtle: #d5d9e5; - --border-control: #8a90a8; - --accent: #4c5caa; + --surface-selected: #e8e3fa; + --surface-raised: #ecebf2; + --text-primary: #1d1b26; + --text-secondary: #5f5b6e; + --border-subtle: #e0dde8; + --border-control: #a19db2; + --accent: #5d4fc4; --on-accent: #ffffff; - --focus-ring: #4c5caa; - --reaction-active: #c02a55; - --danger: #b3261e; - --success: #2c6b4a; - --warning: #7d5a10; - --scrim: #302c2566; + --action: #5244b5; + --bubble-out: #e6e0fb; + --focus-ring: #5d4fc4; + --reaction-active: #5d4fc4; + --danger: #b3304a; + --success: #2d7552; + --warning: #8a5a0e; + --info: #2f5f9e; + --scrim: #1d1b2666; --shadow: 0 16px 42px rgba(30, 34, 51, 0.14); --shadow-sm: 0 2px 8px rgba(30, 34, 51, 0.08); --rel-contact: #6b3fe0; @@ -141,10 +160,6 @@ a { text-decoration: none; } -.notification-card--new { background: var(--accent-soft); border-color: var(--accent); } -.notification-card--new::before { content: ''; width: 7px; height: 7px; border-radius: 50%; background: currentColor; box-shadow: 0 0 10px currentColor; position: absolute; right: 12px; top: 12px; opacity: .9; } -.notification-card { position: relative; } -.notification-new-divider { text-align: center; font-size: 11px; letter-spacing: .12em; opacity: .72; padding: 6px 0; } .channel-view-topbar { position: relative; } diff --git a/shine-solana-arweave-viewer-v2/README.md b/shine-solana-arweave-viewer-v2/README.md deleted file mode 100644 index 48c54e9c..00000000 --- a/shine-solana-arweave-viewer-v2/README.md +++ /dev/null @@ -1,45 +0,0 @@ -# SHiNE Arweave Viewer v2 — ANS-104 / Frame v1 - -Новая версия viewer для формата, где каждый пользовательский блок хранится в Arweave как отдельный ANS-104 DataItem, а `data` DataItem содержит один `SHiNE Frame v1`. - -Основной файл: `index.html`. - -## Быстрый запуск - -Через логин (ключ берётся из Solana PDA): - -```text -index.html?login=aidarkc&channel=books -``` - -Напрямую через blockchain public key, без Solana: - -```text -index.html?key=&channel=books -``` - -Дополнительные параметры: - -```text -&arweaveGateway=https://arweave.net -&solanaRpc=https://api.mainnet-beta.solana.com -``` - -`channel` можно не передавать. Тогда viewer ищет все DataItem пользователя с `App=test5590` и строит список каналов из найденных блоков. - -## Что делает viewer - -1. Если передан `login`, вычисляет PDA `user_login=` программы `SHiNEPr1APdAgNBteUyBXcNovaHctpSjUu8oH2ZJdN6` и читает `blockchainKey`. -2. Если передан `key`, использует его напрямую и не обращается к Solana. -3. Из Ed25519/Solana public key вычисляет Arweave owner address как `base64url(SHA-256(pubkey32))`. -4. Делает Arweave GraphQL запрос по owner + `App=test5590`; при наличии `channel` добавляет тег `c_test5590=`. -5. Загружает payload каждого DataItem через gateway `/`. -6. Разбирает payload как SHiNE Frame v1 (`frameCode=0x0001`, header 56 bytes). -7. Дедуплицирует повторно опубликованные одинаковые пользовательские блоки по SHA-256 Frame v1. -8. Восстанавливает канал/сообщения тем же body parser, который использовал старый viewer. - -## Важно - -При фильтрации по конкретному `channel` viewer получает только блоки с соответствующим тегом `c_test5590`. Поэтому он не заявляет полную проверку глобальной `prevHash`-цепочки пользователя: между двумя блоками одного канала могут существовать блоки других каналов. SHA-256 каждого загруженного Frame вычисляется локально. - -Старый `shine-solana-arweave-viewer/` не изменяется; новая версия лежит отдельно в `shine-solana-arweave-viewer-v2/`. diff --git a/shine-solana-arweave-viewer-v2/history/v1/README.md b/shine-solana-arweave-viewer-v2/history/v1/README.md deleted file mode 100644 index 01f0fcab..00000000 --- a/shine-solana-arweave-viewer-v2/history/v1/README.md +++ /dev/null @@ -1,11 +0,0 @@ -# SHiNE Solana Arweave Viewer - -Основной рабочий файл: - -- `index.html` - -Подробное описание работы, параметров и готовых ссылок: - -- `КАК_ЭТО_РАБОТАЕТ.md` - -Viewer собран как автономный single-file HTML и запускается одним файлом без соседних зависимостей. diff --git a/shine-solana-arweave-viewer-v2/history/v1/index.html b/shine-solana-arweave-viewer-v2/history/v1/index.html deleted file mode 100644 index 72484911..00000000 --- a/shine-solana-arweave-viewer-v2/history/v1/index.html +++ /dev/null @@ -1,2358 +0,0 @@ - - - - - - SHiNE Solana Arweave Viewer - - - - - -
-
-
SHiNE prototype viewer
-

SHiNE Solana Arweave Viewer

-

- Статическая страница для прямого чтения shine_users из Solana, - с настройками RPC и gateway, которые можно передавать через URL и сохранять в браузере. -

-
- -
-
-
-

Настройки доступа

-

Параметры можно сохранить локально и переиспользовать при следующем открытии.

-
- -
- - - - - - - - - - - - -
- Быстрые действия -
- - - -
-
- -
- Проверка доступности -
- - - - -
-
-
- -
Готово к проверке и загрузке.
-
- -
-
-

Текущее состояние

-

Короткая сводка по найденной записи пользователя.

-
-
-
- Логин - — -
-
- PDA - — -
-
- Версия записи - — -
-
- Блокчейн - — -
-
- Arweave TX - — -
-
- Последний блок - — -
-
-
- -
-
-

Полезные ссылки

-

Ссылки формируются из текущих настроек и содержимого PDA.

-
- -
- -
-
-

Содержимое PDA

-

Распарсенные данные записи пользователя из программы shine_users.

-
-
Пока ничего не загружено.
-
- -
-
-

Содержимое блокчейна

-

Viewer скачивает закреплённый блокчейн пользователя из Arweave и локально собирает каналы без сервера SHiNE.

-
-
Сначала загрузите PDA пользователя, затем нажмите «Показать содержимое».
- -
-
-
- - diff --git a/shine-solana-arweave-viewer-v2/history/v1/КАК_ЭТО_РАБОТАЕТ.md b/shine-solana-arweave-viewer-v2/history/v1/КАК_ЭТО_РАБОТАЕТ.md deleted file mode 100644 index 0fb69106..00000000 --- a/shine-solana-arweave-viewer-v2/history/v1/КАК_ЭТО_РАБОТАЕТ.md +++ /dev/null @@ -1,114 +0,0 @@ -# SHiNE Solana Arweave Viewer: как это работает - -## Что лежит в папке - -Основной и единственный рабочий файл viewer: - -- `index.html` - -Это автономный single-file viewer: - -- весь HTML внутри одного файла; -- все стили внутри этого же файла; -- весь JavaScript внутри этого же файла; -- локальная копия `solana-web3` тоже встроена внутрь этого же файла. - -Для запуска viewer достаточно открыть один `index.html`. - -## Что делает viewer - -Viewer открывается как обычная HTML-страница и работает полностью в браузере. - -Он умеет: - -- принимать логин пользователя SHiNE; -- принимать `Solana RPC` через форму или через URL-параметр; -- принимать `Arweave gateway` через форму или через URL-параметр; -- сохранять эти значения в `localStorage`; -- вычислять `user_pda` по логину для программы `shine_users`; -- читать `PDA` напрямую из `Solana`; -- распарсивать содержимое записи `shine_users`; -- показывать ключи, лимиты, номер записи, блокчейн пользователя и `Arweave tx id`; -- строить прямую ссылку на `Arweave`, если `tx id` есть в записи. - -## Какие URL-параметры поддерживаются - -Viewer понимает такие параметры: - -- `login` -- `solanaRpc` -- `arweaveGateway` - -Пример: - -```text -index.html?login=aidartest&solanaRpc=https%3A%2F%2Fsolana-rpc.publicnode.com&arweaveGateway=https%3A%2F%2Farweave.net -``` - -## Предустановленные адреса - -### Solana RPC - -- `https://solana-rpc.publicnode.com` -- `https://public.rpc.solanavibestation.com/` - -### Arweave gateway - -- `https://arweave.net` - -## Почему одна из RPC может не работать - -Адрес: - -- `https://public.rpc.solanavibestation.com/` - -может возвращать браузерную ошибку `403` с текстом про `Origin is not whitelisted`. - -Это означает, что проблема обычно не в SHiNE viewer, а в CORS-политике самого RPC. -Для HTML-страницы, открытой прямо в браузере, это обычно не лечится со стороны клиента. - -Практически для viewer лучше использовать: - -- `https://solana-rpc.publicnode.com` - -## Ссылки на загруженный файл в Arweave - -Основная ссылка: - -- `https://isvg77xrihxyzqnjex3j4uldyao7xbsfda4uhoydtigeugovjvza.arweave.net/RKpv_vFB74zBqSX2nlFjwB37hkUYOUO7A5oMShnVTXI` - -Та же ссылка с тестовым логином `aidartest`: - -- `https://isvg77xrihxyzqnjex3j4uldyao7xbsfda4uhoydtigeugovjvza.arweave.net/RKpv_vFB74zBqSX2nlFjwB37hkUYOUO7A5oMShnVTXI?login=aidartest` - -Та же ссылка с тестовым логином `aidartest` и явным рабочим RPC: - -- `https://isvg77xrihxyzqnjex3j4uldyao7xbsfda4uhoydtigeugovjvza.arweave.net/RKpv_vFB74zBqSX2nlFjwB37hkUYOUO7A5oMShnVTXI?login=aidartest&solanaRpc=https%3A%2F%2Fsolana-rpc.publicnode.com` - -## Что будет, если поставить devnet RPC - -Официальный публичный `Solana devnet RPC`: - -- `https://api.devnet.solana.com` - -Если подставить `devnet` RPC, viewer начнёт читать именно сеть `devnet`, а не `mainnet`. - -Но это не означает автоматически, что вся система SHiNE "стала тестовой". -Для реальной работы в `devnet` должны совпасть сразу несколько условий: - -- программа `shine_users` должна быть задеплоена в `devnet`; -- в `devnet` должен существовать нужный `PDA` для логина; -- формат записи должен совпадать; -- данные пользователя должны реально лежать в этой тестовой сети. - -Если этого нет, viewer просто не найдёт запись. - -## Источник по devnet RPC - -Официальная документация Solana: - -- `https://solana.com/docs/references/clusters` - -Там указан devnet endpoint: - -- `https://api.devnet.solana.com` diff --git a/shine-solana-arweave-viewer-v2/index.html b/shine-solana-arweave-viewer-v2/index.html deleted file mode 100644 index 90091457..00000000 --- a/shine-solana-arweave-viewer-v2/index.html +++ /dev/null @@ -1,3363 +0,0 @@ - - - - - - SHiNE Arweave Viewer v2 — Frame v1 - - - - - -
-
- - - - - -
- -
- - -
- -
Готово к загрузке.
- -
-
-
Viewer читает новый формат Arweave: ?login=...&channel=... или ?key=...&channel=...
-
- - -
-
- - diff --git a/shine-solana-arweave-viewer-v2/КАК_ЭТО_РАБОТАЕТ.md b/shine-solana-arweave-viewer-v2/КАК_ЭТО_РАБОТАЕТ.md deleted file mode 100644 index 26b2ecaa..00000000 --- a/shine-solana-arweave-viewer-v2/КАК_ЭТО_РАБОТАЕТ.md +++ /dev/null @@ -1,39 +0,0 @@ -# Как работает Viewer v2 - -Viewer рассчитан на новый архив SHiNE: **один пользовательский блок = один ANS-104 DataItem**. - -### Режим 1: login + channel - -`?login=&channel=` - -Viewer читает Solana PDA пользователя, получает `blockchainKey`, затем ищет Arweave DataItem этого владельца с тегами `App=test5590` и `c_test5590=`. - -### Режим 2: key + channel - -`?key=&channel=` - -Viewer пропускает Solana и сразу выполняет поиск в Arweave. - -### Режим без channel - -`?login=` или `?key=` - -Viewer получает все доступные DataItem владельца с `App=test5590`, разбирает их и показывает восстановленные каналы. - -### Новый блок - -Payload DataItem: - -```text -uint16be frameCode = 0x0001 -bytes[32] prevHash = SHA-256(previous Frame v1) -int32be blockSize -int32be blockNumber -int64be timestamp seconds -uint16be type -uint16be subType -uint16be version -bytes[N] body -``` - -Подпись пользователя, owner и tags находятся в оболочке ANS-104 DataItem, а не в SHiNE Frame v1. diff --git a/shine-solana-arweave-viewer-v3/README.md b/shine-solana-arweave-viewer-v3/README.md deleted file mode 100644 index 4e9c5523..00000000 --- a/shine-solana-arweave-viewer-v3/README.md +++ /dev/null @@ -1,57 +0,0 @@ -# SHiNE Arweave Viewer v2 — ANS-104 / Frame v1 - -Новая версия viewer для формата, где каждый пользовательский блок хранится в Arweave как отдельный ANS-104 DataItem, а `data` DataItem содержит один `SHiNE Frame v1`. - -Основной файл: `index.html`. - -## Быстрый запуск - -Через логин (ключ берётся из Solana PDA): - -```text -index.html?login=aidarkc&channel=books -``` - -Напрямую через blockchain public key, без Solana: - -```text -index.html?key=&channel=books -``` - -Дополнительные параметры: - -```text -&arweaveGateway=https://arweave.net -&solanaRpc=https://api.mainnet-beta.solana.com -``` - -`channel` можно не передавать. Тогда viewer ищет все DataItem пользователя с `App=test5590` и строит список каналов из найденных блоков. - -## Что делает viewer - -1. Если передан `login`, вычисляет PDA `user_login=` программы `SHiNEPr1APdAgNBteUyBXcNovaHctpSjUu8oH2ZJdN6` и читает `blockchainKey`. -2. Если передан `key`, использует его напрямую и не обращается к Solana. -3. Из Ed25519/Solana public key вычисляет Arweave owner address как `base64url(SHA-256(pubkey32))`. -4. Делает Arweave GraphQL запрос по owner + `App=test5590`; при наличии `channel` добавляет тег `c_test5590=`. -5. Загружает payload каждого DataItem через gateway `/`. -6. Разбирает payload как SHiNE Frame v1 (`frameCode=0x0001`, header 56 bytes). -7. Дедуплицирует повторно опубликованные одинаковые пользовательские блоки по SHA-256 Frame v1. -8. Восстанавливает канал/сообщения тем же body parser, который использовал старый viewer. - -## Важно - -При фильтрации по конкретному `channel` viewer получает только блоки с соответствующим тегом `c_test5590`. Поэтому он не заявляет полную проверку глобальной `prevHash`-цепочки пользователя: между двумя блоками одного канала могут существовать блоки других каналов. SHA-256 каждого загруженного Frame вычисляется локально. - -Старый `shine-solana-arweave-viewer/` не изменяется; новая версия лежит отдельно в `shine-solana-arweave-viewer-v2/`. - - -## Проверка данных (v3.3) -Нижняя строка показывает краткий итог доступных проверок. Нажатие на неё или `⋮ → Проверка данных` открывает отдельный экран: -- локально вычисленный SHA-256 каждого SHiNE Frame; -- `prevHash` общей цепочки, когда предыдущий глобальный блок загружен; -- `prevLineHash` канальной цепочки, когда указанный предыдущий блок загружен; -- наличие DataItem в выборке Arweave owner соответствующего blockchain key; -- разрывы «нет данных» отдельно от доказанных несовпадений; -- честный статус ANS-104 signature: gateway payload/GraphQL не содержит сырой подписи, поэтому она не помечается как локально перепроверенная. - -`○ нет данных` не является ошибкой. `⚠` появляется только при фактическом несовпадении доступных хэшей. diff --git a/shine-solana-arweave-viewer-v3/README_V3.md b/shine-solana-arweave-viewer-v3/README_V3.md deleted file mode 100644 index 5511797a..00000000 --- a/shine-solana-arweave-viewer-v3/README_V3.md +++ /dev/null @@ -1,26 +0,0 @@ -# SHiNE Arweave Viewer v3 - -Viewer нового per-action Arweave формата SHiNE. - -## URL -- `?login=&channel=` — получает blockchain key через Solana PDA, затем читает Arweave. -- `?key=&channel=` — Arweave запускается напрямую; Solana не является блокирующей зависимостью. -- без параметров — стартовая форма (логин или blockchain key + необязательный канал). - -## v3 -- переключатель `Канал / Блоки`; -- рекурсивные комментарии скрыты до раскрытия, на любой глубине; -- light/dark тема; -- меню `⋮`: кэш, Solana RPC, Arweave gateway; -- выключение кэша удаляет сохранённые данные каналов; -- одна нижняя status bar, по нажатию — подробный журнал; -- GraphQL читает от новых Arweave записей к старым (`HEIGHT_DESC`); -- до 6 параллельных загрузок Frame; -- отображение известных типов и raw-представление любых неизвестных блоков в режиме `Блоки`; -- лайки намеренно не отображаются. - -Кэш использует browser localStorage и сериализует BigInt-поля Frame явно. Тема/RPC/gateway являются настройками и не удаляются при отключении кэша. - -## V3.1 — streaming reverse loading - -Arweave history is now processed page-by-page in `HEIGHT_DESC` order. The first GraphQL page (up to 100 DataItems) is downloaded, parsed and rendered immediately. Older pages are then fetched and merged in the background. The bottom status line shows the currently available block range while history expands toward the beginning. Each completed page is also persisted when cache is enabled. diff --git a/shine-solana-arweave-viewer-v3/history/v1/README.md b/shine-solana-arweave-viewer-v3/history/v1/README.md deleted file mode 100644 index 01f0fcab..00000000 --- a/shine-solana-arweave-viewer-v3/history/v1/README.md +++ /dev/null @@ -1,11 +0,0 @@ -# SHiNE Solana Arweave Viewer - -Основной рабочий файл: - -- `index.html` - -Подробное описание работы, параметров и готовых ссылок: - -- `КАК_ЭТО_РАБОТАЕТ.md` - -Viewer собран как автономный single-file HTML и запускается одним файлом без соседних зависимостей. diff --git a/shine-solana-arweave-viewer-v3/history/v1/index.html b/shine-solana-arweave-viewer-v3/history/v1/index.html deleted file mode 100644 index 72484911..00000000 --- a/shine-solana-arweave-viewer-v3/history/v1/index.html +++ /dev/null @@ -1,2358 +0,0 @@ - - - - - - SHiNE Solana Arweave Viewer - - - - - -
-
-
SHiNE prototype viewer
-

SHiNE Solana Arweave Viewer

-

- Статическая страница для прямого чтения shine_users из Solana, - с настройками RPC и gateway, которые можно передавать через URL и сохранять в браузере. -

-
- -
-
-
-

Настройки доступа

-

Параметры можно сохранить локально и переиспользовать при следующем открытии.

-
- -
- - - - - - - - - - - - -
- Быстрые действия -
- - - -
-
- -
- Проверка доступности -
- - - - -
-
-
- -
Готово к проверке и загрузке.
-
- -
-
-

Текущее состояние

-

Короткая сводка по найденной записи пользователя.

-
-
-
- Логин - — -
-
- PDA - — -
-
- Версия записи - — -
-
- Блокчейн - — -
-
- Arweave TX - — -
-
- Последний блок - — -
-
-
- -
-
-

Полезные ссылки

-

Ссылки формируются из текущих настроек и содержимого PDA.

-
- -
- -
-
-

Содержимое PDA

-

Распарсенные данные записи пользователя из программы shine_users.

-
-
Пока ничего не загружено.
-
- -
-
-

Содержимое блокчейна

-

Viewer скачивает закреплённый блокчейн пользователя из Arweave и локально собирает каналы без сервера SHiNE.

-
-
Сначала загрузите PDA пользователя, затем нажмите «Показать содержимое».
- -
-
-
- - diff --git a/shine-solana-arweave-viewer-v3/index.html b/shine-solana-arweave-viewer-v3/index.html deleted file mode 100644 index 2029a446..00000000 --- a/shine-solana-arweave-viewer-v3/index.html +++ /dev/null @@ -1,3438 +0,0 @@ - - - - - - SHiNE Arweave Viewer v3 - - - - - -
- -
SHiNE Viewer
-
-
Готово
- - diff --git a/shine-solana-arweave-viewer/README.md b/shine-solana-arweave-viewer/README.md deleted file mode 100644 index 01f0fcab..00000000 --- a/shine-solana-arweave-viewer/README.md +++ /dev/null @@ -1,11 +0,0 @@ -# SHiNE Solana Arweave Viewer - -Основной рабочий файл: - -- `index.html` - -Подробное описание работы, параметров и готовых ссылок: - -- `КАК_ЭТО_РАБОТАЕТ.md` - -Viewer собран как автономный single-file HTML и запускается одним файлом без соседних зависимостей. diff --git a/shine-solana-arweave-viewer/history/v1/README.md b/shine-solana-arweave-viewer/history/v1/README.md deleted file mode 100644 index 01f0fcab..00000000 --- a/shine-solana-arweave-viewer/history/v1/README.md +++ /dev/null @@ -1,11 +0,0 @@ -# SHiNE Solana Arweave Viewer - -Основной рабочий файл: - -- `index.html` - -Подробное описание работы, параметров и готовых ссылок: - -- `КАК_ЭТО_РАБОТАЕТ.md` - -Viewer собран как автономный single-file HTML и запускается одним файлом без соседних зависимостей. diff --git a/shine-solana-arweave-viewer/history/v1/index.html b/shine-solana-arweave-viewer/history/v1/index.html deleted file mode 100644 index 72484911..00000000 --- a/shine-solana-arweave-viewer/history/v1/index.html +++ /dev/null @@ -1,2358 +0,0 @@ - - - - - - SHiNE Solana Arweave Viewer - - - - - -
-
-
SHiNE prototype viewer
-

SHiNE Solana Arweave Viewer

-

- Статическая страница для прямого чтения shine_users из Solana, - с настройками RPC и gateway, которые можно передавать через URL и сохранять в браузере. -

-
- -
-
-
-

Настройки доступа

-

Параметры можно сохранить локально и переиспользовать при следующем открытии.

-
- -
- - - - - - - - - - - - -
- Быстрые действия -
- - - -
-
- -
- Проверка доступности -
- - - - -
-
-
- -
Готово к проверке и загрузке.
-
- -
-
-

Текущее состояние

-

Короткая сводка по найденной записи пользователя.

-
-
-
- Логин - — -
-
- PDA - — -
-
- Версия записи - — -
-
- Блокчейн - — -
-
- Arweave TX - — -
-
- Последний блок - — -
-
-
- -
-
-

Полезные ссылки

-

Ссылки формируются из текущих настроек и содержимого PDA.

-
- -
- -
-
-

Содержимое PDA

-

Распарсенные данные записи пользователя из программы shine_users.

-
-
Пока ничего не загружено.
-
- -
-
-

Содержимое блокчейна

-

Viewer скачивает закреплённый блокчейн пользователя из Arweave и локально собирает каналы без сервера SHiNE.

-
-
Сначала загрузите PDA пользователя, затем нажмите «Показать содержимое».
- -
-
-
- - diff --git a/shine-solana-arweave-viewer/history/v1/КАК_ЭТО_РАБОТАЕТ.md b/shine-solana-arweave-viewer/history/v1/КАК_ЭТО_РАБОТАЕТ.md deleted file mode 100644 index 0fb69106..00000000 --- a/shine-solana-arweave-viewer/history/v1/КАК_ЭТО_РАБОТАЕТ.md +++ /dev/null @@ -1,114 +0,0 @@ -# SHiNE Solana Arweave Viewer: как это работает - -## Что лежит в папке - -Основной и единственный рабочий файл viewer: - -- `index.html` - -Это автономный single-file viewer: - -- весь HTML внутри одного файла; -- все стили внутри этого же файла; -- весь JavaScript внутри этого же файла; -- локальная копия `solana-web3` тоже встроена внутрь этого же файла. - -Для запуска viewer достаточно открыть один `index.html`. - -## Что делает viewer - -Viewer открывается как обычная HTML-страница и работает полностью в браузере. - -Он умеет: - -- принимать логин пользователя SHiNE; -- принимать `Solana RPC` через форму или через URL-параметр; -- принимать `Arweave gateway` через форму или через URL-параметр; -- сохранять эти значения в `localStorage`; -- вычислять `user_pda` по логину для программы `shine_users`; -- читать `PDA` напрямую из `Solana`; -- распарсивать содержимое записи `shine_users`; -- показывать ключи, лимиты, номер записи, блокчейн пользователя и `Arweave tx id`; -- строить прямую ссылку на `Arweave`, если `tx id` есть в записи. - -## Какие URL-параметры поддерживаются - -Viewer понимает такие параметры: - -- `login` -- `solanaRpc` -- `arweaveGateway` - -Пример: - -```text -index.html?login=aidartest&solanaRpc=https%3A%2F%2Fsolana-rpc.publicnode.com&arweaveGateway=https%3A%2F%2Farweave.net -``` - -## Предустановленные адреса - -### Solana RPC - -- `https://solana-rpc.publicnode.com` -- `https://public.rpc.solanavibestation.com/` - -### Arweave gateway - -- `https://arweave.net` - -## Почему одна из RPC может не работать - -Адрес: - -- `https://public.rpc.solanavibestation.com/` - -может возвращать браузерную ошибку `403` с текстом про `Origin is not whitelisted`. - -Это означает, что проблема обычно не в SHiNE viewer, а в CORS-политике самого RPC. -Для HTML-страницы, открытой прямо в браузере, это обычно не лечится со стороны клиента. - -Практически для viewer лучше использовать: - -- `https://solana-rpc.publicnode.com` - -## Ссылки на загруженный файл в Arweave - -Основная ссылка: - -- `https://isvg77xrihxyzqnjex3j4uldyao7xbsfda4uhoydtigeugovjvza.arweave.net/RKpv_vFB74zBqSX2nlFjwB37hkUYOUO7A5oMShnVTXI` - -Та же ссылка с тестовым логином `aidartest`: - -- `https://isvg77xrihxyzqnjex3j4uldyao7xbsfda4uhoydtigeugovjvza.arweave.net/RKpv_vFB74zBqSX2nlFjwB37hkUYOUO7A5oMShnVTXI?login=aidartest` - -Та же ссылка с тестовым логином `aidartest` и явным рабочим RPC: - -- `https://isvg77xrihxyzqnjex3j4uldyao7xbsfda4uhoydtigeugovjvza.arweave.net/RKpv_vFB74zBqSX2nlFjwB37hkUYOUO7A5oMShnVTXI?login=aidartest&solanaRpc=https%3A%2F%2Fsolana-rpc.publicnode.com` - -## Что будет, если поставить devnet RPC - -Официальный публичный `Solana devnet RPC`: - -- `https://api.devnet.solana.com` - -Если подставить `devnet` RPC, viewer начнёт читать именно сеть `devnet`, а не `mainnet`. - -Но это не означает автоматически, что вся система SHiNE "стала тестовой". -Для реальной работы в `devnet` должны совпасть сразу несколько условий: - -- программа `shine_users` должна быть задеплоена в `devnet`; -- в `devnet` должен существовать нужный `PDA` для логина; -- формат записи должен совпадать; -- данные пользователя должны реально лежать в этой тестовой сети. - -Если этого нет, viewer просто не найдёт запись. - -## Источник по devnet RPC - -Официальная документация Solana: - -- `https://solana.com/docs/references/clusters` - -Там указан devnet endpoint: - -- `https://api.devnet.solana.com` diff --git a/shine-solana-arweave-viewer/index.html b/shine-solana-arweave-viewer/index.html deleted file mode 100644 index dab54b77..00000000 --- a/shine-solana-arweave-viewer/index.html +++ /dev/null @@ -1,3298 +0,0 @@ - - - - - - SHiNE Solana Arweave Viewer - - - - - -
-
- - - - - -
- -
- - -
- -
Готово к загрузке.
- -
-
-
После загрузки PDA viewer покажет список каналов.
-
- - -
-
- - diff --git a/shine-solana-arweave-viewer/КАК_ЭТО_РАБОТАЕТ.md b/shine-solana-arweave-viewer/КАК_ЭТО_РАБОТАЕТ.md deleted file mode 100644 index 0fb69106..00000000 --- a/shine-solana-arweave-viewer/КАК_ЭТО_РАБОТАЕТ.md +++ /dev/null @@ -1,114 +0,0 @@ -# SHiNE Solana Arweave Viewer: как это работает - -## Что лежит в папке - -Основной и единственный рабочий файл viewer: - -- `index.html` - -Это автономный single-file viewer: - -- весь HTML внутри одного файла; -- все стили внутри этого же файла; -- весь JavaScript внутри этого же файла; -- локальная копия `solana-web3` тоже встроена внутрь этого же файла. - -Для запуска viewer достаточно открыть один `index.html`. - -## Что делает viewer - -Viewer открывается как обычная HTML-страница и работает полностью в браузере. - -Он умеет: - -- принимать логин пользователя SHiNE; -- принимать `Solana RPC` через форму или через URL-параметр; -- принимать `Arweave gateway` через форму или через URL-параметр; -- сохранять эти значения в `localStorage`; -- вычислять `user_pda` по логину для программы `shine_users`; -- читать `PDA` напрямую из `Solana`; -- распарсивать содержимое записи `shine_users`; -- показывать ключи, лимиты, номер записи, блокчейн пользователя и `Arweave tx id`; -- строить прямую ссылку на `Arweave`, если `tx id` есть в записи. - -## Какие URL-параметры поддерживаются - -Viewer понимает такие параметры: - -- `login` -- `solanaRpc` -- `arweaveGateway` - -Пример: - -```text -index.html?login=aidartest&solanaRpc=https%3A%2F%2Fsolana-rpc.publicnode.com&arweaveGateway=https%3A%2F%2Farweave.net -``` - -## Предустановленные адреса - -### Solana RPC - -- `https://solana-rpc.publicnode.com` -- `https://public.rpc.solanavibestation.com/` - -### Arweave gateway - -- `https://arweave.net` - -## Почему одна из RPC может не работать - -Адрес: - -- `https://public.rpc.solanavibestation.com/` - -может возвращать браузерную ошибку `403` с текстом про `Origin is not whitelisted`. - -Это означает, что проблема обычно не в SHiNE viewer, а в CORS-политике самого RPC. -Для HTML-страницы, открытой прямо в браузере, это обычно не лечится со стороны клиента. - -Практически для viewer лучше использовать: - -- `https://solana-rpc.publicnode.com` - -## Ссылки на загруженный файл в Arweave - -Основная ссылка: - -- `https://isvg77xrihxyzqnjex3j4uldyao7xbsfda4uhoydtigeugovjvza.arweave.net/RKpv_vFB74zBqSX2nlFjwB37hkUYOUO7A5oMShnVTXI` - -Та же ссылка с тестовым логином `aidartest`: - -- `https://isvg77xrihxyzqnjex3j4uldyao7xbsfda4uhoydtigeugovjvza.arweave.net/RKpv_vFB74zBqSX2nlFjwB37hkUYOUO7A5oMShnVTXI?login=aidartest` - -Та же ссылка с тестовым логином `aidartest` и явным рабочим RPC: - -- `https://isvg77xrihxyzqnjex3j4uldyao7xbsfda4uhoydtigeugovjvza.arweave.net/RKpv_vFB74zBqSX2nlFjwB37hkUYOUO7A5oMShnVTXI?login=aidartest&solanaRpc=https%3A%2F%2Fsolana-rpc.publicnode.com` - -## Что будет, если поставить devnet RPC - -Официальный публичный `Solana devnet RPC`: - -- `https://api.devnet.solana.com` - -Если подставить `devnet` RPC, viewer начнёт читать именно сеть `devnet`, а не `mainnet`. - -Но это не означает автоматически, что вся система SHiNE "стала тестовой". -Для реальной работы в `devnet` должны совпасть сразу несколько условий: - -- программа `shine_users` должна быть задеплоена в `devnet`; -- в `devnet` должен существовать нужный `PDA` для логина; -- формат записи должен совпадать; -- данные пользователя должны реально лежать в этой тестовой сети. - -Если этого нет, viewer просто не найдёт запись. - -## Источник по devnet RPC - -Официальная документация Solana: - -- `https://solana.com/docs/references/clusters` - -Там указан devnet endpoint: - -- `https://api.devnet.solana.com` diff --git a/shine-solana/shine/doc/formats/shine-user-pda-format-v.1.2.md b/shine-solana/shine/doc/formats/shine-user-pda-format-v.1.2.md index 4a2f816c..af7018fe 100644 --- a/shine-solana/shine/doc/formats/shine-user-pda-format-v.1.2.md +++ b/shine-solana/shine/doc/formats/shine-user-pda-format-v.1.2.md @@ -64,7 +64,7 @@ block_version: u8 = 0 root_key: [u8;32] ``` -`root_key` — холодный recovery authority. Blockchain authority не может изменить root. Root authority может изменить root и остальные поля. +`root_key` — холодный recovery authority. Обычные update не используют root. Root участвует только в полной ротации ключей: старый root разрешает переход на одновременно новые `root_key`, `client_key` и blockchain fork. ## ClientKeyBlock @@ -74,7 +74,7 @@ block_version: u8 = 0 client_key: [u8;32] ``` -Client key не является authority PDA. Он может использоваться клиентским уровнем и как fee payer Solana-транзакции. +Client key не является authority PDA. Он может использоваться клиентским уровнем и как fee payer Solana-транзакции. В текущем протоколе смена `client_key` разрешена только как часть полной ротации вместе с root и новым blockchain fork. ## BlockchainRegistryBlock @@ -148,12 +148,13 @@ PDA 1.2 разрешает `server_count = 0` или `1`. Count оставлен - обычный update — активный blockchain key; - новый fork — новый blockchain key; -- root-mode — root нового состояния; -- смена root — новый root. +- полная ротация root + client + blockchain fork — новый blockchain key. На update программа дополнительно требует Ed25519-подпись authority предыдущего состояния по тому же hash нового unsigned state. Эта transition-подпись не хранится внутри PDA. -Blockchain-mode не может изменить root. Root-mode может изменить root и выполнить recovery. Одновременно менять root и добавлять blockchain fork одной транзакцией запрещено. +Blockchain-mode не может изменить root. Для полной ротации используется root-mode: текущий root подписывает hash нового unsigned PDA state как разрешение на переход, а новый blockchain key подписывает тот же hash и его `signature[64]` сохраняется в PDA. Поскольку hash считается по всему unsigned state, обе подписи одновременно фиксируют новый root key, новый client key, новый blockchain fork и остальные поля записи. + +Смена root считается корректной только как полная ротация: root key изменён, client key изменён и в ту же запись добавлен новый blockchain fork. Такая recovery-ротация не ограничивается обычным 72-часовым cooldown blockchain-authority. ## Create diff --git a/shine-solana/shine/doc/programs/shine_users.md b/shine-solana/shine/doc/programs/shine_users.md index c9aea62f..dbb5ebeb 100644 --- a/shine-solana/shine/doc/programs/shine_users.md +++ b/shine-solana/shine/doc/programs/shine_users.md @@ -84,17 +84,22 @@ record_signature:[64] Blockchain-mode: +- используется для всех обычных update; - старый authority = последний blockchain key; -- root менять нельзя; +- `signature[64]` нового состояния = активный blockchain key либо новый blockchain key, если добавляется fork; +- root/client менять нельзя; - новый fork — только после 72 часов от времени активного fork. Root-mode: -- старый authority = root; -- root можно менять; -- recovery fork может обходить 72-часовой cooldown. +- допустим только для recovery/полной ротации ключей; +- старый authority = текущий root; +- полная ротация одной транзакцией меняет `root_key`, `client_key` и добавляет новый blockchain fork; +- transition-подпись делает старый root, а `signature[64]` нового состояния делает новый blockchain key; +- recovery fork может обходить 72-часовой cooldown; +- смена root без одновременной смены client key и добавления нового blockchain fork отклоняется. -Root rotation и blockchain fork одной транзакцией запрещены. +Обе Ed25519-подписи проверяются по одному и тому же hash нового unsigned PDA state, поэтому новые root/client/blockchain public keys входят в подписываемое состояние. ### `5 upsert_promo_seller` Без изменений. diff --git a/shine-solana/shine/programs/shine_users/src/lib.rs b/shine-solana/shine/programs/shine_users/src/lib.rs index 555c69ad..99923f18 100644 --- a/shine-solana/shine/programs/shine_users/src/lib.rs +++ b/shine-solana/shine/programs/shine_users/src/lib.rs @@ -90,6 +90,7 @@ enum ShineUsersError { CannotCloseCurrentFormat = 37, RootChangeRequiresRoot = 38, AmbiguousAuthorityRotation = 39, + RootModeRequiresFullRotation = 40, } impl From for ProgramError { @@ -619,15 +620,20 @@ fn process_update_user_pda(program_id: &Pubkey, accounts: &[AccountInfo], args: require!(args.auth_mode == AUTH_MODE_BLOCKCHAIN || args.auth_mode == AUTH_MODE_ROOT, ShineUsersError::InvalidInstruction); let root_changed = args.root_key != old_record.root_key; - if args.auth_mode == AUTH_MODE_BLOCKCHAIN { - require!(!root_changed, ShineUsersError::RootChangeRequiresRoot); - } - if root_changed && args.new_blockchain_key.is_some() { - return Err(ProgramError::from(ShineUsersError::AmbiguousAuthorityRotation)); + let client_changed = args.client_key != old_record.client_key; + let full_key_rotation = root_changed && client_changed && args.new_blockchain_key.is_some(); + + // root/client меняются только вместе с созданием нового blockchain fork. + // Обычные update и обычный fork всегда авторизуются текущим blockchain key. + if root_changed || client_changed { + require!(full_key_rotation, ShineUsersError::AmbiguousAuthorityRotation); + require!(args.auth_mode == AUTH_MODE_ROOT, ShineUsersError::RootChangeRequiresRoot); + } else { + require!(args.auth_mode == AUTH_MODE_BLOCKCHAIN, ShineUsersError::RootModeRequiresFullRotation); } let old_active_key = old_record.active_fork()?.blockchain_key; - let old_authority = if args.auth_mode == AUTH_MODE_ROOT { old_record.root_key } else { old_active_key }; + let old_authority = if full_key_rotation { old_record.root_key } else { old_active_key }; let mut forks = old_record.forks.clone(); let additional_limit_u32 = u32::try_from(args.additional_limit).map_err(|_| ProgramError::from(ShineUsersError::PaidLimitTooLarge))?; @@ -636,7 +642,7 @@ fn process_update_user_pda(program_id: &Pubkey, accounts: &[AccountInfo], args: for fork in &forks { require!(fork.blockchain_key != new_key, ShineUsersError::DuplicateBlockchainKey); } - if args.auth_mode == AUTH_MODE_BLOCKCHAIN { + if !full_key_rotation { enforce_fork_cooldown(old_record.active_fork()?.created_at_ms, args.updated_at_ms)?; } @@ -664,12 +670,8 @@ fn process_update_user_pda(program_id: &Pubkey, accounts: &[AccountInfo], args: signature: [0; 64], }; - let record_signer = if root_changed { - new_record.root_key - } else if let Some(new_key) = appended_key { + let record_signer = if let Some(new_key) = appended_key { new_key - } else if args.auth_mode == AUTH_MODE_ROOT { - new_record.root_key } else { new_record.active_fork()?.blockchain_key }; diff --git a/tools/test-publisher/AGENTS.md b/tools/test-publisher/AGENTS.md index d4ea31e7..40f5edae 100644 --- a/tools/test-publisher/AGENTS.md +++ b/tools/test-publisher/AGENTS.md @@ -35,7 +35,7 @@ JWK используется только подготовщиком. Не по - `prevHash` глобальной цепочки. - `prevLineNumber/prevLineHash` канальной линии. - ANS-104 signing/deepHash без сверки с серверной реализацией. -- `App=test5590` и `c=` без согласованного изменения импортера/Viewer. +- текущий `App=` и `c=` без согласованного изменения импортера/Viewer. ## Viewer Viewer распознаёт Arweave URL в тексте POST и показывает изображения inline. Экран «Проверка данных» независимо считает SHA-256 Frame, проверяет доступные `prevHash` и `prevLineHash`, показывает отсутствие соседнего блока как «нет данных», а доказанное несовпадение — как ошибку. Подпись ANS-104 нельзя помечать локально проверенной, если gateway не предоставил сырую подпись DataItem. diff --git a/tools/test-publisher/protocol_tags.py b/tools/test-publisher/protocol_tags.py new file mode 100644 index 00000000..9a1d7eeb --- /dev/null +++ b/tools/test-publisher/protocol_tags.py @@ -0,0 +1,23 @@ +from pathlib import Path +import re + +_UI_PROTOCOL_TAGS = Path(__file__).resolve().parents[2] / 'shine-UI' / 'js' / 'services' / 'protocol-tags.js' +_NAMESPACE_RE = re.compile(r"SHINE_PROTOCOL_NAMESPACE\s*=\s*['\"]([^'\"]+)['\"]") + + +def _read_namespace() -> str: + source = _UI_PROTOCOL_TAGS.read_text(encoding='utf-8') + match = _NAMESPACE_RE.search(source) + if not match: + raise RuntimeError(f'Не найден SHINE_PROTOCOL_NAMESPACE в {_UI_PROTOCOL_TAGS}') + value = match.group(1).strip() + if not value: + raise RuntimeError('SHiNE protocol namespace пуст') + return value + + +NAMESPACE = _read_namespace() +APP_TAG_NAME = 'App' +APP_TAG_VALUE = NAMESPACE +CHANNEL_TAG_NAME = 'c' +TYPE_TAG_NAME = 't' diff --git a/tools/test-publisher/v1/publisher/publisher.py b/tools/test-publisher/v1/publisher/publisher.py index 013a87fb..1b80b2a9 100644 --- a/tools/test-publisher/v1/publisher/publisher.py +++ b/tools/test-publisher/v1/publisher/publisher.py @@ -1,11 +1,24 @@ #!/usr/bin/env python3 import argparse, asyncio, base64, hashlib, json, os, random, struct, sys, time, uuid from pathlib import Path +import re from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey from websockets.asyncio.client import connect ZERO32 = bytes(32) FRAME_CODE_V1=1; TEXT_TYPE=1; TEXT_POST=10; VERSION=1 +def shine_protocol_namespace(): + here = Path(__file__).resolve() + for parent in here.parents: + cfg = parent / 'shine-UI' / 'js' / 'services' / 'protocol-tags.js' + if cfg.exists(): + m = re.search(r"SHINE_PROTOCOL_NAMESPACE\s*=\s*['\"]([^'\"]+)['\"]", cfg.read_text(encoding='utf-8')) + if m: + return m.group(1) + raise RuntimeError('Не найден shine-UI/js/services/protocol-tags.js с SHINE_PROTOCOL_NAMESPACE') + +SHINE_PROTOCOL_NAMESPACE = shine_protocol_namespace() + def atomic_json(path, obj): path=Path(path); path.parent.mkdir(parents=True, exist_ok=True) @@ -54,9 +67,9 @@ def post_body(line_code, prev_line_num, prev_line_hash, this_line_num, text): if len(tb)>65535: raise ValueError('post text too long') return struct.pack('>ii32siH',line_code,prev_line_num,prev_line_hash,this_line_num,len(tb))+tb -def frame(prev_hash, block_num, body, ts=None): - ts=int(time.time()) if ts is None else int(ts); size=56+len(body) - return struct.pack('>H32siiqHHH',FRAME_CODE_V1,prev_hash,size,block_num,ts,TEXT_TYPE,TEXT_POST,VERSION)+body +def frame(prev_hash, back32_hash, block_num, body, ts=None): + ts=int(time.time()) if ts is None else int(ts); size=88+len(body) + return struct.pack('>H32s32siiqHHH',FRAME_CODE_V1,prev_hash,back32_hash,size,block_num,ts,TEXT_TYPE,TEXT_POST,VERSION)+body def h32(b): return hashlib.sha256(b).digest() def hx(b): return b.hex() @@ -139,7 +152,7 @@ async def publish_one(cfg,st,items): else: print('Queue exhausted. Nothing to publish.'); return False text=items[idx]['text'].strip(); block_num=int(st['last_block_number'])+1; prev_hash=bytes.fromhex(st['last_block_hash']); this_line=int(st['last_line_number'])+1 body=post_body(int(cfg['channel_root_block_number']),int(st['last_line_number']),bytes.fromhex(st['last_line_hash']),this_line,text) - fr=frame(prev_hash,block_num,body); block_hash=h32(fr); tags=[('App','test5590'),('c',cfg['channel_name'].strip().lower())] + back32_hash=ZERO32 if block_num<32 else bytes.fromhex((await block(cfg,block_num-32))[0]); fr=frame(prev_hash,back32_hash,block_num,body); block_hash=h32(fr); tags=[('App',SHINE_PROTOCOL_NAMESPACE),('c',cfg['channel_name'].strip().lower())] raw=data_item(read_key(cfg['key_file']),tags,fr) nextidx=idx+1 p={'queue_index':idx,'next_index_after':nextidx,'block_number':block_num,'block_hash':hx(block_hash),'previous_block_number':st['last_block_number'],'previous_block_hash':st['last_block_hash'],'this_line_number':this_line,'data_item_b64':base64.b64encode(raw).decode()} diff --git a/tools/test-publisher/v2/publisher/publisher.py b/tools/test-publisher/v2/publisher/publisher.py index 013a87fb..1b80b2a9 100644 --- a/tools/test-publisher/v2/publisher/publisher.py +++ b/tools/test-publisher/v2/publisher/publisher.py @@ -1,11 +1,24 @@ #!/usr/bin/env python3 import argparse, asyncio, base64, hashlib, json, os, random, struct, sys, time, uuid from pathlib import Path +import re from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey from websockets.asyncio.client import connect ZERO32 = bytes(32) FRAME_CODE_V1=1; TEXT_TYPE=1; TEXT_POST=10; VERSION=1 +def shine_protocol_namespace(): + here = Path(__file__).resolve() + for parent in here.parents: + cfg = parent / 'shine-UI' / 'js' / 'services' / 'protocol-tags.js' + if cfg.exists(): + m = re.search(r"SHINE_PROTOCOL_NAMESPACE\s*=\s*['\"]([^'\"]+)['\"]", cfg.read_text(encoding='utf-8')) + if m: + return m.group(1) + raise RuntimeError('Не найден shine-UI/js/services/protocol-tags.js с SHINE_PROTOCOL_NAMESPACE') + +SHINE_PROTOCOL_NAMESPACE = shine_protocol_namespace() + def atomic_json(path, obj): path=Path(path); path.parent.mkdir(parents=True, exist_ok=True) @@ -54,9 +67,9 @@ def post_body(line_code, prev_line_num, prev_line_hash, this_line_num, text): if len(tb)>65535: raise ValueError('post text too long') return struct.pack('>ii32siH',line_code,prev_line_num,prev_line_hash,this_line_num,len(tb))+tb -def frame(prev_hash, block_num, body, ts=None): - ts=int(time.time()) if ts is None else int(ts); size=56+len(body) - return struct.pack('>H32siiqHHH',FRAME_CODE_V1,prev_hash,size,block_num,ts,TEXT_TYPE,TEXT_POST,VERSION)+body +def frame(prev_hash, back32_hash, block_num, body, ts=None): + ts=int(time.time()) if ts is None else int(ts); size=88+len(body) + return struct.pack('>H32s32siiqHHH',FRAME_CODE_V1,prev_hash,back32_hash,size,block_num,ts,TEXT_TYPE,TEXT_POST,VERSION)+body def h32(b): return hashlib.sha256(b).digest() def hx(b): return b.hex() @@ -139,7 +152,7 @@ async def publish_one(cfg,st,items): else: print('Queue exhausted. Nothing to publish.'); return False text=items[idx]['text'].strip(); block_num=int(st['last_block_number'])+1; prev_hash=bytes.fromhex(st['last_block_hash']); this_line=int(st['last_line_number'])+1 body=post_body(int(cfg['channel_root_block_number']),int(st['last_line_number']),bytes.fromhex(st['last_line_hash']),this_line,text) - fr=frame(prev_hash,block_num,body); block_hash=h32(fr); tags=[('App','test5590'),('c',cfg['channel_name'].strip().lower())] + back32_hash=ZERO32 if block_num<32 else bytes.fromhex((await block(cfg,block_num-32))[0]); fr=frame(prev_hash,back32_hash,block_num,body); block_hash=h32(fr); tags=[('App',SHINE_PROTOCOL_NAMESPACE),('c',cfg['channel_name'].strip().lower())] raw=data_item(read_key(cfg['key_file']),tags,fr) nextidx=idx+1 p={'queue_index':idx,'next_index_after':nextidx,'block_number':block_num,'block_hash':hx(block_hash),'previous_block_number':st['last_block_number'],'previous_block_hash':st['last_block_hash'],'this_line_number':this_line,'data_item_b64':base64.b64encode(raw).decode()} diff --git a/tools/test-publisher/v2/publisher/publisher_multi.py b/tools/test-publisher/v2/publisher/publisher_multi.py index fe33f91c..aac928a2 100644 --- a/tools/test-publisher/v2/publisher/publisher_multi.py +++ b/tools/test-publisher/v2/publisher/publisher_multi.py @@ -1,6 +1,7 @@ #!/usr/bin/env python3 import argparse, asyncio, base64, hashlib, json, os, random, struct, sys, time, uuid from pathlib import Path +import re from datetime import datetime, timedelta from zoneinfo import ZoneInfo from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey @@ -8,6 +9,18 @@ from websockets.asyncio.client import connect ZERO32 = bytes(32) FRAME_CODE_V1=1; TEXT_TYPE=1; TEXT_POST=10; VERSION=1 +def shine_protocol_namespace(): + here = Path(__file__).resolve() + for parent in here.parents: + cfg = parent / 'shine-UI' / 'js' / 'services' / 'protocol-tags.js' + if cfg.exists(): + m = re.search(r"SHINE_PROTOCOL_NAMESPACE\s*=\s*['\"]([^'\"]+)['\"]", cfg.read_text(encoding='utf-8')) + if m: + return m.group(1) + raise RuntimeError('Не найден shine-UI/js/services/protocol-tags.js с SHINE_PROTOCOL_NAMESPACE') + +SHINE_PROTOCOL_NAMESPACE = shine_protocol_namespace() + def atomic_json(path, obj): path=Path(path); path.parent.mkdir(parents=True, exist_ok=True) @@ -56,9 +69,9 @@ def post_body(line_code, prev_line_num, prev_line_hash, this_line_num, text): if len(tb)>65535: raise ValueError('post text too long') return struct.pack('>ii32siH',line_code,prev_line_num,prev_line_hash,this_line_num,len(tb))+tb -def frame(prev_hash, block_num, body, ts=None): - ts=int(time.time()) if ts is None else int(ts); size=56+len(body) - return struct.pack('>H32siiqHHH',FRAME_CODE_V1,prev_hash,size,block_num,ts,TEXT_TYPE,TEXT_POST,VERSION)+body +def frame(prev_hash, back32_hash, block_num, body, ts=None): + ts=int(time.time()) if ts is None else int(ts); size=88+len(body) + return struct.pack('>H32s32siiqHHH',FRAME_CODE_V1,prev_hash,back32_hash,size,block_num,ts,TEXT_TYPE,TEXT_POST,VERSION)+body def h32(b): return hashlib.sha256(b).digest() def hx(b): return b.hex() @@ -141,7 +154,7 @@ async def publish_one(cfg,st,items): else: print('Queue exhausted. Nothing to publish.'); return False text=items[idx]['text'].strip(); block_num=int(st['last_block_number'])+1; prev_hash=bytes.fromhex(st['last_block_hash']); this_line=int(st['last_line_number'])+1 body=post_body(int(cfg['channel_root_block_number']),int(st['last_line_number']),bytes.fromhex(st['last_line_hash']),this_line,text) - fr=frame(prev_hash,block_num,body); block_hash=h32(fr); tags=[('App','test5590'),('c',cfg['channel_name'].strip().lower())] + back32_hash=ZERO32 if block_num<32 else bytes.fromhex((await block(cfg,block_num-32))[0]); fr=frame(prev_hash,back32_hash,block_num,body); block_hash=h32(fr); tags=[('App',SHINE_PROTOCOL_NAMESPACE),('c',cfg['channel_name'].strip().lower())] raw=data_item(read_key(cfg['key_file']),tags,fr) nextidx=idx+1 p={'queue_index':idx,'next_index_after':nextidx,'block_number':block_num,'block_hash':hx(block_hash),'previous_block_number':st['last_block_number'],'previous_block_hash':st['last_block_hash'],'this_line_number':this_line,'data_item_b64':base64.b64encode(raw).decode()} @@ -236,7 +249,7 @@ async def publish_channel(cfg,st,ch,force=False): prev_line_block=int(cs.get('last_line_block_number', ch['channel_root_block_number'])) body=post_body(int(ch['channel_root_block_number']),prev_line_block,bytes.fromhex(cs['last_line_hash']),this_line,text) fr=frame(prev_hash,block_num,body); block_hash=h32(fr) - tags=[('App','test5590'),('c',ch['channel_name'].strip().lower())] + tags=[('App',SHINE_PROTOCOL_NAMESPACE),('c',ch['channel_name'].strip().lower())] raw=data_item(read_key(cfg['key_file']),tags,fr) p={'channel_name':ch['channel_name'],'queue_index':idx,'next_index_after':idx+1,'block_number':block_num, 'block_hash':hx(block_hash),'previous_block_number':st['last_block_number'],'previous_block_hash':st['last_block_hash'],