Аввив 2.0 - работает, заливка!!

.gitignore

@@ -105,6 +105,7 @@ ESP32/**/*.a
 # Полные серверные бэкапы (тяжёлые архивы, не коммитим)
 deploy/backup/archive/**
 !deploy/backup/archive/.gitkeep
+SHiNE-bundle-*.zip
 
 # Локальная дев-обвязка AI-агентов (сессии, планы, настройки) — не коммитим
 .agents/

PATCH_MANIFEST.md

@@ -0,0 +1,29 @@
+# SHiNE ANS-104 `test5590` patch
+
+Этот архив содержит **только новые/изменённые файлы** плюс `DELETE_FILES.txt`.
+
+## Что меняется
+
+- Frame v1 без поддержки старого формата.
+- Один пользовательский block = готовый Ed25519 ANS-104 DataItem.
+- Test tag: `App=test5590`; channel tag: `c=<canonical slug>`.
+- SHiNE `prevHash` остаётся `SHA-256(FrameV1Bytes)` и не зависит от Arweave ID.
+- PostgreSQL — единственное локальное хранилище пользовательских blocks.
+- Старый custom SHINE-ARCHIVE и filesystem blockchain storage удаляются.
+- Каждые ~15 минут локальные pending DataItems собираются в standard ANS-104 bundle и идут через существующий native Arweave L1 transport.
+- Другие серверы находят `App=test5590`, импортируют и не публикуют повторно.
+- `ESP32/**` **не изменён**.
+
+## Состав
+
+- изменено/добавлено файлов: 46
+- удалить файлов: 41
+
+Применение и проверки: `docs/Blockchain/CODEX_APPLY_ANS104_TEST5590_PATCH.md`.
+
+## Проверки при сборке patch
+
+- `node --check` для изменённых production JS: OK.
+- `diff -qr` каталога `ESP32` относительно исходного архива: без изменений.
+- Active Java refs на удалённые SHINE-ARCHIVE/file-recovery classes: отсутствуют.
+- `./gradlew testClasses --offline --no-daemon`: не запущен до компиляции, потому что wrapper требует скачать Gradle 8.14 с `services.gradle.org`, а рабочая среда не имеет внешнего сетевого доступа. Полный Gradle test обязателен после применения patch в dev-среде.

SHiNE-server/shine-server-archive/build.gradle

@@ -0,0 +1,31 @@
+plugins {
+    id 'java'
+}
+
+group = 'shine'
+version = '1.0.0'
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(17)
+    }
+}
+
+repositories { mavenCentral() }
+
+dependencies {
+    implementation project(':shine-server-config')
+    implementation project(':shine-server-db')
+    implementation project(':shine-server-crypto')
+    implementation project(':shine-server-blockchain')
+    implementation project(':shine-server-net-protocol')
+    implementation project(':shine-server-solana-users-sync')
+
+    implementation 'com.fasterxml.jackson.core:jackson-databind:2.17.2'
+    implementation 'org.bouncycastle:bcprov-jdk18on:1.78.1'
+    implementation 'org.slf4j:slf4j-api:2.0.16'
+
+    testImplementation 'org.junit.jupiter:junit-jupiter:5.11.0'
+}
+
+test { useJUnitPlatform() }

SHiNE-server/shine-server-archive/src/main/java/server/archive/Ans104Bundle.java

@@ -0,0 +1,103 @@
+package server.archive;
+
+import blockchain.Ans104DataItem;
+
+import java.io.ByteArrayOutputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/** Minimal ANS-104 binary bundle writer/reader. */
+public final class Ans104Bundle {
+    public record Entry(byte[] id32, byte[] rawDataItem) {}
+
+    private Ans104Bundle() {}
+
+    public static byte[] write(List<byte[]> rawItems) {
+        if (rawItems == null || rawItems.isEmpty()) throw new IllegalArgumentException("ANS-104 bundle is empty");
+        if (rawItems.size() > 1_000_000) throw new IllegalArgumentException("Too many ANS-104 items");
+
+        List<Ans104DataItem> parsed = new ArrayList<>(rawItems.size());
+        long total = 32L + 64L * rawItems.size();
+        for (byte[] raw : rawItems) {
+            Ans104DataItem item = new Ans104DataItem(raw);
+            if (!item.verifySignature()) throw new IllegalArgumentException("Invalid ANS-104 DataItem signature");
+            parsed.add(item);
+            total = Math.addExact(total, raw.length);
+        }
+        if (total > Integer.MAX_VALUE) throw new IllegalArgumentException("Bundle too large for in-memory publisher: " + total);
+
+        ByteArrayOutputStream out = new ByteArrayOutputStream((int) total);
+        out.writeBytes(uint256LE(rawItems.size()));
+        for (int i = 0; i < rawItems.size(); i++) {
+            out.writeBytes(uint256LE(rawItems.get(i).length));
+            out.writeBytes(parsed.get(i).id32());
+        }
+        for (byte[] raw : rawItems) out.writeBytes(raw);
+        return out.toByteArray();
+    }
+
+    public static List<Entry> read(byte[] bundle, int maxItems) {
+        if (bundle == null || bundle.length < 32) throw new IllegalArgumentException("ANS-104 bundle too short");
+        long countLong = readUint256AsLong(bundle, 0);
+        if (countLong <= 0 || countLong > Math.max(1, maxItems)) {
+            throw new IllegalArgumentException("Bad ANS-104 bundle item count: " + countLong);
+        }
+        int count = (int) countLong;
+        long headerLong = 32L + 64L * count;
+        if (headerLong > bundle.length) throw new IllegalArgumentException("ANS-104 bundle header truncated");
+        int header = (int) headerLong;
+        long[] sizes = new long[count];
+        byte[][] ids = new byte[count][];
+        int hp = 32;
+        long payloadBytes = 0;
+        for (int i = 0; i < count; i++) {
+            sizes[i] = readUint256AsLong(bundle, hp); hp += 32;
+            ids[i] = Arrays.copyOfRange(bundle, hp, hp + 32); hp += 32;
+            if (sizes[i] <= 0 || sizes[i] > Integer.MAX_VALUE) throw new IllegalArgumentException("Bad DataItem size: " + sizes[i]);
+            payloadBytes = Math.addExact(payloadBytes, sizes[i]);
+        }
+        if (headerLong + payloadBytes != bundle.length) {
+            throw new IllegalArgumentException("ANS-104 bundle size mismatch: header=" + headerLong + " payload=" + payloadBytes + " actual=" + bundle.length);
+        }
+        List<Entry> out = new ArrayList<>(count);
+        int p = header;
+        for (int i = 0; i < count; i++) {
+            int len = (int) sizes[i];
+            byte[] raw = Arrays.copyOfRange(bundle, p, p + len);
+            p += len;
+            Ans104DataItem item = new Ans104DataItem(raw);
+            if (!Arrays.equals(ids[i], item.id32())) throw new IllegalArgumentException("Bundle entry ID mismatch at index " + i);
+            out.add(new Entry(ids[i], raw));
+        }
+        return out;
+    }
+
+    public static byte[] find(byte[] bundle, byte[] wantedId32, int maxItems) {
+        if (wantedId32 == null || wantedId32.length != 32) throw new IllegalArgumentException("wanted ID must be 32 bytes");
+        for (Entry e : read(bundle, maxItems)) {
+            if (Arrays.equals(e.id32(), wantedId32)) return e.rawDataItem();
+        }
+        return null;
+    }
+
+    /** ANS-104 bundle integers are 32-byte unsigned little-endian values. */
+    static byte[] uint256LE(long value) {
+        if (value < 0) throw new IllegalArgumentException("negative uint256");
+        byte[] out = new byte[32];
+        long v = value;
+        for (int i = 0; i < 8; i++) { out[i] = (byte) (v & 0xff); v >>>= 8; }
+        return out;
+    }
+
+    static long readUint256AsLong(byte[] data, int offset) {
+        if (offset < 0 || offset + 32 > data.length) throw new IllegalArgumentException("uint256 truncated");
+        for (int i = offset + 8; i < offset + 32; i++) {
+            if (data[i] != 0) throw new IllegalArgumentException("uint256 exceeds signed long range");
+        }
+        long v = 0;
+        for (int i = 7; i >= 0; i--) v = (v << 8) | (data[offset + i] & 0xffL);
+        if (v < 0) throw new IllegalArgumentException("uint256 exceeds signed long range");
+        return v;
+    }
+}

SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockPublisherScheduler.java

@@ -0,0 +1,37 @@
+package server.archive;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/** Fixed-delay publisher. Empty cycles are no-ops. */
+public final class ArweaveBlockPublisherScheduler {
+    private static final Logger log = LoggerFactory.getLogger(ArweaveBlockPublisherScheduler.class);
+    private static final AtomicBoolean STARTED = new AtomicBoolean(false);
+    private static ScheduledExecutorService executor;
+
+    private ArweaveBlockPublisherScheduler() {}
+
+    public static void startOrLog() {
+        ArweaveBlocksConfig cfg;
+        try { cfg = ArweaveBlocksConfig.load(); cfg.validatePublisher(); }
+        catch (Exception e) { log.error("Cannot read/validate Arweave block publisher config", e); return; }
+        if (!cfg.publishEnabled()) { log.info("Arweave user-block publisher disabled"); return; }
+        if (!STARTED.compareAndSet(false,true)) return;
+        try {
+            ArweaveBlockPublisherService 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: interval={}m gateway={}", cfg.publishIntervalMinutes(), cfg.publishGateway());
+        } catch (Exception e) { 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(); }
+}

SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockPublisherService.java

@@ -0,0 +1,59 @@
+package server.archive;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import shine.db.dao.BlocksDAO;
+import shine.db.entities.BlockEntry;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/** Publishes locally-created signed user DataItems as one standard ANS-104 bundle. */
+public final class ArweaveBlockPublisherService {
+    private static final Logger log = LoggerFactory.getLogger(ArweaveBlockPublisherService.class);
+
+    private final ArweaveBlocksConfig cfg;
+    private final BlocksDAO blocksDAO = BlocksDAO.getInstance();
+    private final ArweaveL1Uploader uploader;
+
+    public ArweaveBlockPublisherService(ArweaveBlocksConfig cfg) {
+        this.cfg = cfg;
+        this.uploader = new ArweaveL1Uploader(cfg);
+    }
+
+    public int runCycle() throws Exception {
+        List<BlockEntry> candidates = blocksDAO.listPendingArweave(cfg.publishMaxItems());
+        if (candidates.isEmpty()) return 0;
+
+        List<byte[]> items = new ArrayList<>();
+        List<byte[]> ids = new ArrayList<>();
+        long estimated = 32;
+        for (BlockEntry e : candidates) {
+            byte[] raw = e.getBlockBytes();
+            byte[] id = e.getDataItemId();
+            if (raw == null || raw.length == 0 || id == null || id.length != 32) continue;
+            long next = estimated + 64L + raw.length;
+            if (!items.isEmpty() && next > cfg.publishMaxBundleBytes()) break;
+            if (next > cfg.publishMaxBundleBytes()) {
+                log.error("One DataItem exceeds arweave.blocks.publish.maxBundleBytes: chain={} block={} bytes={}",
+                        e.getBchName(), e.getBlockNumber(), raw.length);
+                continue;
+            }
+            items.add(raw); ids.add(id); estimated = next;
+        }
+        if (items.isEmpty()) return 0;
+
+        byte[] bundle = Ans104Bundle.write(items);
+        List<ArweaveL1Uploader.Tag> rootTags = List.of(
+                new ArweaveL1Uploader.Tag("Content-Type", "application/octet-stream"),
+                new ArweaveL1Uploader.Tag("Bundle-Format", "binary"),
+                new ArweaveL1Uploader.Tag("Bundle-Version", "2.0.0"),
+                // Deliberately different from App=test5590 so discovery returns child DataItems only.
+                new ArweaveL1Uploader.Tag("App", "test5590-batch")
+        );
+        ArweaveL1Uploader.UploadResult result = uploader.upload(bundle, rootTags);
+        blocksDAO.markArweavePublished(ids, result.txId(), System.currentTimeMillis());
+        log.info("Published {} SHiNE test DataItems in root tx {} (bundle={} bytes)", items.size(), result.txId(), bundle.length);
+        return items.size();
+    }
+}

SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncScheduler.java

@@ -0,0 +1,32 @@
+package server.archive;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public final class ArweaveBlockSyncScheduler {
+    private static final Logger log = LoggerFactory.getLogger(ArweaveBlockSyncScheduler.class);
+    private static final AtomicBoolean STARTED = new AtomicBoolean(false);
+    private static ScheduledExecutorService executor;
+    private ArweaveBlockSyncScheduler() {}
+
+    public static void startOrLog() {
+        ArweaveBlocksConfig cfg;
+        try { cfg = ArweaveBlocksConfig.load(); }
+        catch (Exception e) { log.error("Cannot read Arweave block sync config", e); return; }
+        if (!cfg.syncEnabled()) { log.info("Arweave user-block sync disabled"); return; }
+        if (!STARTED.compareAndSet(false,true)) return;
+        try {
+            ArweaveBlockSyncService service = new ArweaveBlockSyncService(cfg);
+            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);}};
+            executor.scheduleWithFixedDelay(task,0,cfg.syncIntervalMinutes(),TimeUnit.MINUTES);
+            log.info("Arweave user-block sync enabled: interval={}m gateway={}",cfg.syncIntervalMinutes(),cfg.syncGateway());
+        } 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();}
+}

SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncService.java

@@ -0,0 +1,185 @@
+package server.archive;
+
+import blockchain.Ans104DataItem;
+import blockchain.BchBlockEntry;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import server.logic.ws_protocol.JSON.handlers.blockchain.Net_AddBlock_Handler;
+import shine.db.dao.ArweaveBlockImportDAO;
+import shine.db.dao.BlockchainStateDAO;
+import shine.db.dao.BlocksDAO;
+import shine.db.dao.SolanaUserPdaCurrentDAO;
+import shine.db.entities.BlockchainStateEntry;
+import shine.db.entities.SolanaUserPdaCurrentEntry;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.util.*;
+
+/**
+ * Discovers App=test5590 child DataItems, extracts their exact serialized bytes
+ * from the root ANS-104 bundle and imports them through the normal AddBlock checks.
+ */
+public final class ArweaveBlockSyncService {
+    private static final Logger log = LoggerFactory.getLogger(ArweaveBlockSyncService.class);
+    private static final ObjectMapper MAPPER = new ObjectMapper();
+    private static final Base64.Decoder B64URL = Base64.getUrlDecoder();
+
+    private final ArweaveBlocksConfig cfg;
+    private final HttpClient http = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(20)).build();
+    private final ArweaveBlockImportDAO importDAO = ArweaveBlockImportDAO.getInstance();
+    private final BlocksDAO blocksDAO = BlocksDAO.getInstance();
+    private final SolanaUserPdaCurrentDAO usersDAO = SolanaUserPdaCurrentDAO.getInstance();
+    private final BlockchainStateDAO stateDAO = BlockchainStateDAO.getInstance();
+    private final Net_AddBlock_Handler addBlock = new Net_AddBlock_Handler();
+
+    public ArweaveBlockSyncService(ArweaveBlocksConfig cfg) { this.cfg = cfg; }
+
+    public void runCycle() throws Exception {
+        discover();
+        drainQueue();
+    }
+
+    private void discover() throws Exception {
+        long stored = importDAO.getLastBlockHeight();
+        long minHeight = Math.max(cfg.syncStartBlockHeight(), stored);
+        String cursor = null;
+        long maxHeight = minHeight;
+        Map<String, byte[]> rootCache = new HashMap<>();
+        int discovered = 0;
+
+        do {
+            JsonNode response = graphQlPage(minHeight, cursor);
+            JsonNode txs = response.path("data").path("transactions");
+            if (response.has("errors")) throw new IOException("Arweave GraphQL errors: " + response.path("errors"));
+            JsonNode edges = txs.path("edges");
+            if (!edges.isArray()) throw new IOException("Arweave GraphQL returned no transactions.edges");
+
+            String nextCursor = null;
+            for (JsonNode edge : edges) {
+                nextCursor = edge.path("cursor").asText(null);
+                JsonNode node = edge.path("node");
+                String itemIdText = node.path("id").asText("").trim();
+                String rootTx = node.path("bundledIn").path("id").asText("").trim();
+                long height = node.path("block").path("height").asLong(-1L);
+                if (itemIdText.isBlank() || rootTx.isBlank() || height < 0) continue;
+                maxHeight = Math.max(maxHeight, height);
+                byte[] id32;
+                try { id32 = B64URL.decode(itemIdText); }
+                catch (IllegalArgumentException bad) { continue; }
+                if (id32.length != 32 || blocksDAO.existsByDataItemId(id32) || importDAO.exists(id32)) continue;
+
+                byte[] bundle = rootCache.computeIfAbsent(rootTx, key -> {
+                    try { return downloadRootBundle(key); }
+                    catch (Exception e) { throw new RootDownloadRuntimeException(e); }
+                });
+                byte[] raw = Ans104Bundle.find(bundle, id32, Math.max(cfg.publishMaxItems() * 4, 100_000));
+                if (raw == null) throw new IOException("DataItem " + itemIdText + " not found in root bundle " + rootTx);
+                Ans104DataItem parsed = new Ans104DataItem(raw);
+                if (!parsed.hasTag(ArweaveBlocksConfig.TEST_TAG_NAME, ArweaveBlocksConfig.TEST_TAG_VALUE)) continue;
+                if (!parsed.verifySignature()) throw new IOException("Bad ANS-104 signature for " + itemIdText);
+                importDAO.enqueueIfMissing(id32, rootTx, height, raw, System.currentTimeMillis());
+                discovered++;
+            }
+            boolean hasNext = txs.path("pageInfo").path("hasNextPage").asBoolean(false);
+            cursor = hasNext ? nextCursor : null;
+            if (hasNext && (cursor == null || cursor.isBlank())) throw new IOException("GraphQL hasNextPage without cursor");
+        } while (cursor != null);
+
+        // Keep one-height overlap: the next query includes this height and deduplicates IDs.
+        importDAO.setLastBlockHeight(maxHeight, System.currentTimeMillis());
+        if (discovered > 0) log.info("Arweave discovery queued {} new SHiNE test DataItems through height {}", discovered, maxHeight);
+    }
+
+    private void drainQueue() throws Exception {
+        int passes = 0;
+        int importedTotal = 0;
+        boolean progress;
+        do {
+            progress = false;
+            List<ArweaveBlockImportDAO.QueueItem> pending = importDAO.listPending(cfg.syncQueueBatchSize());
+            if (pending.isEmpty()) break;
+            for (ArweaveBlockImportDAO.QueueItem q : pending) {
+                Ans104DataItem item;
+                BchBlockEntry block;
+                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");
+                    block = new BchBlockEntry(q.rawDataItem());
+                } catch (Exception e) {
+                    importDAO.reject(q.dataItemId(), "invalid_data_item: " + e.getMessage(), 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());
+                    continue;
+                }
+                ensureState(user);
+                Net_AddBlock_Handler.ArweaveImportResult result = addBlock.addBlockFromArweave(user.getBlockchainName(), q.rawDataItem());
+                if (result.ok()) {
+                    importDAO.delete(q.dataItemId());
+                    importedTotal++; progress = true;
+                    continue;
+                }
+                String reason = result.reasonCode();
+                if ("bad_block_number".equals(reason) || "bad_prev_hash".equals(reason)
+                        || "prev_line_block_not_found".equals(reason) || "channel_not_found".equals(reason)
+                        || "chain_resync_in_progress".equals(reason)) {
+                    importDAO.setPendingError(q.dataItemId(), reason, System.currentTimeMillis());
+                } else {
+                    importDAO.reject(q.dataItemId(), reason, System.currentTimeMillis());
+                }
+            }
+            passes++;
+        } while (progress && passes < 8);
+        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);
+    }
+
+    private JsonNode graphQlPage(long minHeight, String cursor) throws Exception {
+        String after = cursor == null ? "null" : "\"" + escapeGraphQl(cursor) + "\"";
+        String query = "query { transactions(tags:[{name:\"App\",values:[\"test5590\"]}], block:{min:" + minHeight + "}, first:" + cfg.syncPageSize() + ", after:" + after + ", sort:HEIGHT_ASC) { pageInfo { hasNextPage } edges { cursor node { id bundledIn { id } block { height } } } } }";
+        String body = MAPPER.writeValueAsString(Map.of("query", query));
+        HttpRequest req = HttpRequest.newBuilder(URI.create(trim(cfg.syncGateway()) + "/graphql"))
+                .timeout(Duration.ofSeconds(60)).header("Content-Type","application/json").header("Accept","application/json")
+                .POST(HttpRequest.BodyPublishers.ofString(body, StandardCharsets.UTF_8)).build();
+        HttpResponse<String> resp = http.send(req, HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
+        if (resp.statusCode() < 200 || resp.statusCode() >= 300) throw new IOException("GraphQL HTTP " + resp.statusCode());
+        return MAPPER.readTree(resp.body());
+    }
+
+    private byte[] downloadRootBundle(String txId) throws Exception {
+        HttpRequest req = HttpRequest.newBuilder(URI.create(trim(cfg.syncGateway()) + "/" + txId))
+                .timeout(Duration.ofMinutes(5)).GET().build();
+        HttpResponse<byte[]> resp = http.send(req, HttpResponse.BodyHandlers.ofByteArray());
+        if (resp.statusCode() < 200 || resp.statusCode() >= 300) throw new IOException("Arweave root HTTP " + resp.statusCode() + " tx=" + txId);
+        byte[] body = resp.body();
+        if (body == null || body.length == 0) throw new IOException("Empty Arweave root bundle " + txId);
+        if (body.length > cfg.syncMaxRootBundleBytes()) throw new IOException("Root bundle exceeds syncMaxRootBundleBytes: " + body.length);
+        return body;
+    }
+
+    private static String trim(String s){return String.valueOf(s==null?"":s).trim().replaceAll("/+$","");}
+    private static String escapeGraphQl(String s){return s.replace("\\","\\\\").replace("\"","\\\"");}
+    private static final class RootDownloadRuntimeException extends RuntimeException { RootDownloadRuntimeException(Throwable cause){super(cause);} }
+}

SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlocksConfig.java

@@ -0,0 +1,66 @@
+package server.archive;
+
+import utils.config.AppConfig;
+
+import java.nio.file.Path;
+
+/** Configuration of the new per-user-block ANS-104 Arweave transport. */
+public record ArweaveBlocksConfig(
+        boolean publishEnabled,
+        int publishIntervalMinutes,
+        int publishMaxItems,
+        long publishMaxBundleBytes,
+        String publishGateway,
+        Path walletJwkPath,
+        int minConfirmations,
+        int confirmPollSeconds,
+        int confirmTimeoutMinutes,
+        boolean syncEnabled,
+        int syncIntervalMinutes,
+        int syncPageSize,
+        int syncQueueBatchSize,
+        long syncStartBlockHeight,
+        long syncMaxRootBundleBytes,
+        String syncGateway
+) {
+    public static final String TEST_TAG_NAME = "App";
+    public static final String TEST_TAG_VALUE = "test5590";
+    public static final String CHANNEL_TAG_NAME = "c";
+
+    public static ArweaveBlocksConfig load() {
+        AppConfig c = AppConfig.getInstance();
+        return new ArweaveBlocksConfig(
+                c.getBoolean("arweave.blocks.publish.enabled", false),
+                positive(c.getInt("arweave.blocks.publish.intervalMinutes", 15), "publish.intervalMinutes"),
+                positive(c.getInt("arweave.blocks.publish.maxItems", 10_000), "publish.maxItems"),
+                positiveLong(parseLong(c.getParam("arweave.blocks.publish.maxBundleBytes"), 128L * 1024 * 1024), "publish.maxBundleBytes"),
+                orDefault(c.getParam("arweave.blocks.publish.gateway"), "https://arweave.net"),
+                optionalPath(c.getParam("arweave.blocks.publish.walletJwkPath")),
+                nonNegative(c.getInt("arweave.blocks.publish.minConfirmations", 0), "publish.minConfirmations"),
+                positive(c.getInt("arweave.blocks.publish.confirmPollSeconds", 30), "publish.confirmPollSeconds"),
+                positive(c.getInt("arweave.blocks.publish.confirmTimeoutMinutes", 180), "publish.confirmTimeoutMinutes"),
+                c.getBoolean("arweave.blocks.sync.enabled", false),
+                positive(c.getInt("arweave.blocks.sync.intervalMinutes", 15), "sync.intervalMinutes"),
+                clamp(c.getInt("arweave.blocks.sync.pageSize", 100), 1, 100),
+                positive(c.getInt("arweave.blocks.sync.queueBatchSize", 10_000), "sync.queueBatchSize"),
+                nonNegativeLong(parseLong(c.getParam("arweave.blocks.sync.startBlockHeight"), 0L), "sync.startBlockHeight"),
+                positiveLong(parseLong(c.getParam("arweave.blocks.sync.maxRootBundleBytes"), 256L * 1024 * 1024), "sync.maxRootBundleBytes"),
+                orDefault(c.getParam("arweave.blocks.sync.gateway"), "https://turbo-gateway.com")
+        );
+    }
+
+    public void validatePublisher() {
+        if (publishEnabled && walletJwkPath == null) {
+            throw new IllegalArgumentException("arweave.blocks.publish.walletJwkPath is required when publisher is enabled");
+        }
+    }
+
+    private static String orDefault(String v, String d) { return v == null || v.isBlank() ? d : v.trim(); }
+    private static Path optionalPath(String v) { return v == null || v.isBlank() ? null : Path.of(v.trim()); }
+    private static long parseLong(String v, long d) { return v == null || v.isBlank() ? d : Long.parseLong(v.trim()); }
+    private static int positive(int v,String n){if(v<=0)throw new IllegalArgumentException(n+" must be >0");return v;}
+    private static int nonNegative(int v,String n){if(v<0)throw new IllegalArgumentException(n+" must be >=0");return v;}
+    private static long positiveLong(long v,String n){if(v<=0)throw new IllegalArgumentException(n+" must be >0");return v;}
+    private static long nonNegativeLong(long v,String n){if(v<0)throw new IllegalArgumentException(n+" must be >=0");return v;}
+    private static int clamp(int v,int min,int max){return Math.max(min,Math.min(max,v));}
+}

SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveL1Uploader.java

@@ -0,0 +1,141 @@
+package server.archive;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.math.BigInteger;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.security.*;
+import java.security.spec.MGF1ParameterSpec;
+import java.security.spec.PSSParameterSpec;
+import java.security.spec.RSAPrivateCrtKeySpec;
+import java.time.Duration;
+import java.util.*;
+
+/** Existing native Arweave L1 transport adapted to upload in-memory ANS-104 bundles. */
+public final class ArweaveL1Uploader {
+    private static final Logger log = LoggerFactory.getLogger(ArweaveL1Uploader.class);
+    private static final ObjectMapper MAPPER = new ObjectMapper();
+    private static final Base64.Encoder B64 = Base64.getUrlEncoder().withoutPadding();
+    private static final Base64.Decoder B64D = Base64.getUrlDecoder();
+
+    public record Tag(String name, String value) {}
+    public record UploadResult(String txId, byte[] txIdBytes) {}
+
+    private final ArweaveBlocksConfig cfg;
+    private final HttpClient http = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(20)).build();
+    private volatile Wallet wallet;
+
+    public ArweaveL1Uploader(ArweaveBlocksConfig cfg) { this.cfg = Objects.requireNonNull(cfg); }
+
+    public UploadResult upload(byte[] data, List<Tag> tags) throws Exception {
+        if (data == null || data.length == 0) throw new IllegalArgumentException("Arweave upload data is empty");
+        Wallet w = wallet();
+        String gateway = trimGateway(cfg.publishGateway());
+        ArweaveMerkle.Prepared merkle = ArweaveMerkle.prepare(data);
+        String anchor = getRequiredText(gateway, "/tx_anchor");
+        String reward = getRequiredText(gateway, "/price/" + data.length);
+        if (!reward.matches("^\\d+$")) throw new IOException("Bad Arweave price: " + reward);
+        verifyBalance(gateway, w.address(), reward);
+
+        List<List<byte[]>> tagList = new ArrayList<>();
+        List<Map<String,String>> jsonTags = new ArrayList<>();
+        for (Tag tag : tags == null ? List.<Tag>of() : tags) addTag(jsonTags, tagList, tag.name(), tag.value());
+
+        byte[] signaturePayload = deepHash(List.of(
+                utf8("2"), b64Decode(w.owner()), new byte[0], utf8("0"), utf8(reward),
+                b64Decode(anchor), tagList, utf8(Integer.toString(data.length)), merkle.dataRoot()
+        ));
+        byte[] rawSignature = signPayload(w.privateKey(), signaturePayload);
+        byte[] txIdBytes = sha256(rawSignature);
+        String txId = b64(txIdBytes);
+
+        Map<String,Object> tx = new LinkedHashMap<>();
+        tx.put("format",2); tx.put("id",txId); tx.put("last_tx",anchor); tx.put("owner",w.owner());
+        tx.put("tags",jsonTags); tx.put("target",""); tx.put("quantity","0");
+        tx.put("data_root",b64(merkle.dataRoot())); tx.put("data_size",Integer.toString(data.length)); tx.put("data","");
+        tx.put("reward",reward); tx.put("signature",b64(rawSignature));
+        postJsonExpect2xx(gateway + "/tx", tx, Duration.ofSeconds(60));
+
+        for (int i=0;i<merkle.chunks().size();i++) {
+            ArweaveMerkle.Chunk meta=merkle.chunks().get(i); ArweaveMerkle.Proof proof=merkle.proofs().get(i);
+            Map<String,Object> body=new LinkedHashMap<>();
+            body.put("data_root",b64(merkle.dataRoot())); body.put("data_size",Integer.toString(data.length));
+            body.put("data_path",b64(proof.proof())); body.put("offset",Long.toString(proof.offset()));
+            body.put("chunk",b64(ArweaveMerkle.readChunk(data,meta)));
+            postChunkWithRetry(gateway,body,i,merkle.chunks().size());
+        }
+        if (cfg.minConfirmations() > 0) waitForConfirmations(txId);
+        log.info("ANS-104 bundle uploaded to Arweave: tx={} bytes={} items-transported",txId,data.length);
+        return new UploadResult(txId,txIdBytes);
+    }
+
+    private int waitForConfirmations(String txId) throws Exception {
+        String gateway=trimGateway(cfg.publishGateway());
+        long deadline=System.currentTimeMillis()+cfg.confirmTimeoutMinutes()*60_000L; int last=0;
+        while(System.currentTimeMillis()<deadline){
+            HttpRequest req=HttpRequest.newBuilder(URI.create(gateway+"/tx/"+txId+"/status")).timeout(Duration.ofSeconds(20)).GET().build();
+            HttpResponse<String> resp=http.send(req,HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
+            if(resp.statusCode()==200){JsonNode j=MAPPER.readTree(resp.body());last=j.path("number_of_confirmations").asInt(0);if(last>=cfg.minConfirmations())return last;}
+            else if(resp.statusCode()!=202&&resp.statusCode()!=404)log.warn("Arweave status tx={} HTTP {}",txId,resp.statusCode());
+            Thread.sleep(cfg.confirmPollSeconds()*1000L);
+        }
+        throw new IOException("Arweave confirmation timeout for "+txId+", last="+last);
+    }
+
+    private void postChunkWithRetry(String gateway,Map<String,Object> body,int index,int total)throws Exception{
+        Exception last=null;
+        for(int attempt=1;attempt<=12;attempt++)try{postJsonExpect2xx(gateway+"/chunk",body,Duration.ofSeconds(60));return;}catch(Exception e){last=e;if(attempt==12)break;Thread.sleep(5000L);}
+        throw new IOException("Failed Arweave chunk "+(index+1)+"/"+total,last);
+    }
+    private void postJsonExpect2xx(String url,Object body,Duration timeout)throws Exception{
+        HttpRequest req=HttpRequest.newBuilder(URI.create(url)).timeout(timeout).header("Content-Type","application/json").header("Accept","application/json")
+                .POST(HttpRequest.BodyPublishers.ofString(MAPPER.writeValueAsString(body),StandardCharsets.UTF_8)).build();
+        HttpResponse<String> resp=http.send(req,HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
+        if(resp.statusCode()<200||resp.statusCode()>=300)throw new IOException("HTTP "+resp.statusCode()+" "+safe(resp.body()));
+    }
+    private void verifyBalance(String gateway,String address,String reward)throws Exception{
+        String balance=getRequiredText(gateway,"/wallet/"+address+"/balance");
+        if(balance.matches("^\\d+$")&&new BigInteger(balance).compareTo(new BigInteger(reward))<0)throw new IllegalStateException("Not enough AR: balance="+balance+" reward="+reward);
+    }
+    private String getRequiredText(String gateway,String path)throws Exception{
+        HttpRequest req=HttpRequest.newBuilder(URI.create(gateway+path)).timeout(Duration.ofSeconds(20)).GET().build();
+        HttpResponse<String> resp=http.send(req,HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
+        if(resp.statusCode()<200||resp.statusCode()>=300)throw new IOException("Arweave HTTP "+resp.statusCode()+" for "+path+": "+safe(resp.body()));
+        String s=resp.body()==null?"":resp.body().trim();if(s.isBlank())throw new IOException("Empty Arweave response for "+path);return s;
+    }
+    private Wallet wallet()throws Exception{
+        Wallet local=wallet;if(local!=null)return local;synchronized(this){if(wallet!=null)return wallet;
+            JsonNode jwk=MAPPER.readTree(Files.readString(cfg.walletJwkPath(),StandardCharsets.UTF_8));String owner=required(jwk,"n");
+            PrivateKey pk=buildPrivateKey(jwk);String address=b64(sha256(b64Decode(owner)));return wallet=new Wallet(owner,address,pk);}
+    }
+    private static PrivateKey buildPrivateKey(JsonNode jwk)throws GeneralSecurityException{
+        RSAPrivateCrtKeySpec spec=new RSAPrivateCrtKeySpec(big(required(jwk,"n")),big(required(jwk,"e")),big(required(jwk,"d")),big(required(jwk,"p")),big(required(jwk,"q")),big(required(jwk,"dp")),big(required(jwk,"dq")),big(required(jwk,"qi")));
+        return KeyFactory.getInstance("RSA").generatePrivate(spec);
+    }
+    private static byte[] signPayload(PrivateKey key,byte[] payload)throws GeneralSecurityException{
+        Signature s=Signature.getInstance("RSASSA-PSS");s.setParameter(new PSSParameterSpec("SHA-256","MGF1",MGF1ParameterSpec.SHA256,32,1));s.initSign(key);s.update(payload);return s.sign();
+    }
+    private static byte[] deepHash(Object data)throws GeneralSecurityException{
+        if(data instanceof List<?> list){byte[] acc=sha384(utf8("list"+list.size()));for(Object item:list)acc=sha384(concat(acc,deepHash(item)));return acc;}
+        if(!(data instanceof byte[] bytes))throw new IllegalArgumentException("deepHash byte[]/List expected");return sha384(concat(sha384(utf8("blob"+bytes.length)),sha384(bytes)));
+    }
+    private static void addTag(List<Map<String,String>> json,List<List<byte[]>> raw,String name,String value){byte[]n=utf8(name),v=utf8(value);Map<String,String>m=new LinkedHashMap<>();m.put("name",b64(n));m.put("value",b64(v));json.add(m);raw.add(List.of(n,v));}
+    private static String required(JsonNode n,String f){String s=n==null?"":n.path(f).asText("").trim();if(s.isBlank())throw new IllegalStateException("Arweave JWK missing "+f);return s;}
+    private static BigInteger big(String s){return new BigInteger(1,b64Decode(s));}
+    private static String trimGateway(String s){return(s==null?"https://arweave.net":s.trim()).replaceAll("/+$","");}
+    private static byte[] utf8(String s){return String.valueOf(s==null?"":s).getBytes(StandardCharsets.UTF_8);}
+    private static byte[] b64Decode(String s){return B64D.decode(s);}private static String b64(byte[]b){return B64.encodeToString(b);}
+    private static byte[] sha256(byte[]b)throws GeneralSecurityException{return MessageDigest.getInstance("SHA-256").digest(b);}private static byte[] sha384(byte[]b)throws GeneralSecurityException{return MessageDigest.getInstance("SHA-384").digest(b);}
+    private static byte[] concat(byte[]...a){int n=0;for(byte[]x:a)n=Math.addExact(n,x.length);byte[]o=new byte[n];int p=0;for(byte[]x:a){System.arraycopy(x,0,o,p,x.length);p+=x.length;}return o;}
+    private static String safe(String s){s=String.valueOf(s==null?"":s).replace('\n',' ').replace('\r',' ').trim();return s.length()<=250?s:s.substring(0,250)+"...";}
+    private record Wallet(String owner,String address,PrivateKey privateKey){}
+}

SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveMerkle.java

@@ -0,0 +1,206 @@
+package server.archive;
+
+import java.io.*;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.*;
+
+/**
+ * Arweave v2 data Merkle tree/proofs. Алгоритм повторяет arweave-js merkle.ts.
+ */
+final class ArweaveMerkle {
+    static final int MAX_CHUNK_SIZE = 256 * 1024;
+    static final int MIN_CHUNK_SIZE = 32 * 1024;
+
+    record Chunk(byte[] dataHash, long minByteRange, long maxByteRange) {
+        long size() { return maxByteRange - minByteRange; }
+    }
+    record Proof(long offset, byte[] proof) {}
+    record Prepared(byte[] dataRoot, List<Chunk> chunks, List<Proof> proofs) {}
+
+    private sealed interface Node permits Leaf, Branch {
+        byte[] id();
+        long maxByteRange();
+    }
+    private record Leaf(byte[] id, byte[] dataHash, long minByteRange, long maxByteRange) implements Node {}
+    private record Branch(byte[] id, long byteRange, long maxByteRange, Node left, Node right) implements Node {}
+
+    private ArweaveMerkle() {}
+
+
+    static Prepared prepare(byte[] data) throws IOException {
+        if (data == null || data.length == 0) throw new IOException("Arweave data is empty");
+        List<Chunk> chunks = chunkBytes(data);
+        List<Node> leaves = new ArrayList<>(chunks.size());
+        for (Chunk c : chunks) {
+            byte[] id = sha256(concat(sha256(c.dataHash()), sha256(note(c.maxByteRange()))));
+            leaves.add(new Leaf(id, c.dataHash(), c.minByteRange(), c.maxByteRange()));
+        }
+        Node root = buildLayers(leaves);
+        List<Proof> proofs = new ArrayList<>();
+        resolveProofs(root, new byte[0], proofs);
+        if (!chunks.isEmpty() && chunks.get(chunks.size() - 1).size() == 0) {
+            chunks = new ArrayList<>(chunks);
+            chunks.remove(chunks.size() - 1);
+            proofs.remove(proofs.size() - 1);
+        }
+        if (chunks.size() != proofs.size()) throw new IOException("Arweave Merkle: chunks/proofs mismatch");
+        return new Prepared(root.id(), List.copyOf(chunks), List.copyOf(proofs));
+    }
+
+    private static List<Chunk> chunkBytes(byte[] data) {
+        List<Chunk> out = new ArrayList<>();
+        long remaining = data.length;
+        long cursor = 0;
+        int p = 0;
+        while (remaining >= MAX_CHUNK_SIZE) {
+            long chunkSize = MAX_CHUNK_SIZE;
+            long next = remaining - MAX_CHUNK_SIZE;
+            if (next > 0 && next < MIN_CHUNK_SIZE) chunkSize = (remaining + 1) / 2;
+            byte[] chunk = Arrays.copyOfRange(data, p, p + (int) chunkSize);
+            out.add(new Chunk(sha256(chunk), cursor, cursor + chunkSize));
+            p += (int) chunkSize;
+            cursor += chunkSize;
+            remaining -= chunkSize;
+        }
+        byte[] rest = Arrays.copyOfRange(data, p, p + (int) remaining);
+        out.add(new Chunk(sha256(rest), cursor, cursor + remaining));
+        return out;
+    }
+
+    static byte[] readChunk(byte[] data, Chunk c) throws IOException {
+        long len = c.size();
+        if (data == null || len < 0 || len > Integer.MAX_VALUE || c.minByteRange() < 0 || c.maxByteRange() > data.length) {
+            throw new IOException("Invalid Arweave chunk range");
+        }
+        return Arrays.copyOfRange(data, (int) c.minByteRange(), (int) c.maxByteRange());
+    }
+
+    static Prepared prepare(Path file) throws IOException {
+        long fileSize = Files.size(file);
+        List<Chunk> chunks = chunkFile(file, fileSize);
+        List<Node> leaves = new ArrayList<>(chunks.size());
+        for (Chunk c : chunks) {
+            byte[] id = sha256(concat(sha256(c.dataHash()), sha256(note(c.maxByteRange()))));
+            leaves.add(new Leaf(id, c.dataHash(), c.minByteRange(), c.maxByteRange()));
+        }
+        if (leaves.isEmpty()) throw new IOException("Arweave Merkle: нет leaves");
+        Node root = buildLayers(leaves);
+        List<Proof> proofs = new ArrayList<>();
+        resolveProofs(root, new byte[0], proofs);
+
+        // arweave-js строит root вместе с нулевым последним chunk при точном кратном 256KiB,
+        // но сам нулевой chunk/proof не загружает.
+        if (!chunks.isEmpty() && chunks.get(chunks.size() - 1).size() == 0) {
+            chunks = new ArrayList<>(chunks);
+            chunks.remove(chunks.size() - 1);
+            proofs.remove(proofs.size() - 1);
+        }
+        if (chunks.size() != proofs.size()) throw new IOException("Arweave Merkle: chunks/proofs mismatch");
+        return new Prepared(root.id(), List.copyOf(chunks), List.copyOf(proofs));
+    }
+
+    private static List<Chunk> chunkFile(Path file, long fileSize) throws IOException {
+        List<Chunk> out = new ArrayList<>();
+        long remaining = fileSize;
+        long cursor = 0;
+        try (InputStream in = new BufferedInputStream(Files.newInputStream(file))) {
+            while (remaining >= MAX_CHUNK_SIZE) {
+                long chunkSize = MAX_CHUNK_SIZE;
+                long next = remaining - MAX_CHUNK_SIZE;
+                if (next > 0 && next < MIN_CHUNK_SIZE) {
+                    chunkSize = (remaining + 1) / 2;
+                }
+                byte[] data = readExact(in, (int)chunkSize);
+                out.add(new Chunk(sha256(data), cursor, cursor + chunkSize));
+                cursor += chunkSize;
+                remaining -= chunkSize;
+            }
+            byte[] rest = readExact(in, (int)remaining);
+            out.add(new Chunk(sha256(rest), cursor, cursor + remaining));
+        }
+        return out;
+    }
+
+    private static Node buildLayers(List<Node> nodes) {
+        if (nodes.size() < 2) return nodes.get(0);
+        List<Node> next = new ArrayList<>((nodes.size() + 1) / 2);
+        for (int i = 0; i < nodes.size(); i += 2) {
+            Node left = nodes.get(i);
+            Node right = i + 1 < nodes.size() ? nodes.get(i + 1) : null;
+            if (right == null) {
+                next.add(left);
+                continue;
+            }
+            long byteRange = left.maxByteRange();
+            byte[] id = sha256(concat(
+                    sha256(left.id()),
+                    sha256(right.id()),
+                    sha256(note(byteRange))
+            ));
+            next.add(new Branch(id, byteRange, right.maxByteRange(), left, right));
+        }
+        return buildLayers(next);
+    }
+
+    private static void resolveProofs(Node node, byte[] prefix, List<Proof> out) {
+        if (node instanceof Leaf leaf) {
+            out.add(new Proof(leaf.maxByteRange() - 1,
+                    concat(prefix, leaf.dataHash(), note(leaf.maxByteRange()))));
+            return;
+        }
+        Branch b = (Branch) node;
+        byte[] partial = concat(prefix, b.left().id(), b.right().id(), note(b.byteRange()));
+        resolveProofs(b.left(), partial, out);
+        resolveProofs(b.right(), partial, out);
+    }
+
+    static byte[] readChunk(Path file, Chunk c) throws IOException {
+        long len = c.size();
+        if (len < 0 || len > Integer.MAX_VALUE) throw new IOException("Некорректный Arweave chunk size: " + len);
+        try (RandomAccessFile raf = new RandomAccessFile(file.toFile(), "r")) {
+            raf.seek(c.minByteRange());
+            byte[] data = new byte[(int)len];
+            raf.readFully(data);
+            return data;
+        }
+    }
+
+    private static byte[] readExact(InputStream in, int len) throws IOException {
+        byte[] out = new byte[len];
+        int pos = 0;
+        while (pos < len) {
+            int n = in.read(out, pos, len - pos);
+            if (n < 0) throw new EOFException("Неожиданный EOF");
+            pos += n;
+        }
+        return out;
+    }
+
+    private static byte[] note(long value) {
+        if (value < 0) throw new IllegalArgumentException("negative note");
+        byte[] out = new byte[32];
+        long v = value;
+        for (int i = 31; i >= 0 && v != 0; i--) {
+            out[i] = (byte)(v & 0xff);
+            v >>>= 8;
+        }
+        return out;
+    }
+
+    private static byte[] sha256(byte[] data) {
+        try { return MessageDigest.getInstance("SHA-256").digest(data); }
+        catch (NoSuchAlgorithmException e) { throw new IllegalStateException(e); }
+    }
+
+    private static byte[] concat(byte[]... arrays) {
+        int len = 0;
+        for (byte[] a : arrays) len = Math.addExact(len, a.length);
+        byte[] out = new byte[len];
+        int p=0;
+        for (byte[] a : arrays) { System.arraycopy(a,0,out,p,a.length); p+=a.length; }
+        return out;
+    }
+}

SHiNE-server/shine-server-archive/src/test/java/server/archive/Ans104BundleTest.java

@@ -0,0 +1,36 @@
+package server.archive;
+
+import blockchain.Ans104DataItem;
+import org.junit.jupiter.api.Test;
+import utils.crypto.Ed25519Util;
+
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+final class Ans104BundleTest {
+    @Test
+    void writeReadAndFindPreserveExactDataItems() {
+        byte[] a = item("a");
+        byte[] b = item("b");
+        byte[] bundle = Ans104Bundle.write(List.of(a, b));
+
+        List<Ans104Bundle.Entry> entries = Ans104Bundle.read(bundle, 10);
+        assertEquals(2, entries.size());
+        assertArrayEquals(a, entries.get(0).rawDataItem());
+        assertArrayEquals(b, entries.get(1).rawDataItem());
+
+        byte[] bId = new Ans104DataItem(b).id32();
+        assertArrayEquals(b, Ans104Bundle.find(bundle, bId, 10));
+    }
+
+    private static byte[] item(String payload) {
+        byte[] privateKey = Ed25519Util.generatePrivateKeyFromString("bundle-" + payload);
+        byte[] owner = Ed25519Util.derivePublicKey(privateKey);
+        byte[] data = payload.getBytes(StandardCharsets.UTF_8);
+        List<Ans104DataItem.Tag> tags = List.of(new Ans104DataItem.Tag("App", "test5590"));
+        byte[] signature = Ed25519Util.sign(Ans104DataItem.buildSigningMessage(owner, tags, data), privateKey);
+        return Ans104DataItem.serializeEd25519(signature, owner, tags, data);
+    }
+}

SHiNE-server/shine-server-blockchain/src/main/java/blockchain/Ans104DataItem.java

@@ -0,0 +1,363 @@
+package blockchain;
+
+import utils.crypto.Ed25519Util;
+
+import java.io.ByteArrayOutputStream;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * Minimal ANS-104 DataItem parser/verifier used by SHiNE.
+ *
+ * SHiNE accepts only generic Ed25519 signature type 2:
+ *   uint16le signatureType
+ *   signature[64]
+ *   owner[32]
+ *   target_present[1] + target[32] when present
+ *   anchor_present[1] + anchor[32] when present
+ *   tags_count uint64le
+ *   tags_size  uint64le
+ *   avro_tags[tags_size]
+ *   data[*]
+ *
+ * The signing message matches the deployed arbundles/Turbo DataItem implementation:
+ * deepHash(["dataitem", "1", signatureType, owner, target, anchor, rawAvroTags, data]).
+ */
+public final class Ans104DataItem {
+    public static final int SIGNATURE_TYPE_ED25519 = 2;
+    public static final int SIGNATURE_LEN = 64;
+    public static final int OWNER_LEN = 32;
+    public static final int OPTIONAL_FIELD_LEN = 32;
+    public static final int ID_LEN = 32;
+    public static final int MAX_DATA_ITEM_BYTES = 8 * 1024 * 1024;
+    public static final int MAX_TAGS_BYTES = 64 * 1024;
+    public static final long MAX_TAGS_COUNT = 128;
+
+    public record Tag(String name, String value) {}
+
+    private final int signatureType;
+    private final byte[] signature;
+    private final byte[] owner;
+    private final byte[] target;
+    private final byte[] anchor;
+    private final long tagsCount;
+    private final byte[] rawTags;
+    private final List<Tag> tags;
+    private final byte[] data;
+    private final byte[] rawBytes;
+    private final byte[] id;
+
+    public Ans104DataItem(byte[] bytes) {
+        Objects.requireNonNull(bytes, "bytes == null");
+        if (bytes.length < 2 + SIGNATURE_LEN + OWNER_LEN + 1 + 1 + 8 + 8 + 1) {
+            throw new IllegalArgumentException("ANS-104 DataItem too short: " + bytes.length);
+        }
+        if (bytes.length > MAX_DATA_ITEM_BYTES) {
+            throw new IllegalArgumentException("ANS-104 DataItem too large: " + bytes.length);
+        }
+
+        ByteBuffer bb = ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN);
+        this.signatureType = Short.toUnsignedInt(bb.getShort());
+        if (signatureType != SIGNATURE_TYPE_ED25519) {
+            throw new IllegalArgumentException("Unsupported ANS-104 signature type: " + signatureType + " (expected 2)");
+        }
+
+        this.signature = readExact(bb, SIGNATURE_LEN, "signature");
+        this.owner = readExact(bb, OWNER_LEN, "owner");
+        this.target = readOptional32(bb, "target");
+        this.anchor = readOptional32(bb, "anchor");
+
+        this.tagsCount = readUnsignedLongAsNonNegative(bb, "tags_count");
+        long tagsSizeLong = readUnsignedLongAsNonNegative(bb, "tags_size");
+        if (tagsCount > MAX_TAGS_COUNT) {
+            throw new IllegalArgumentException("Too many ANS-104 tags: " + tagsCount);
+        }
+        if (tagsSizeLong > MAX_TAGS_BYTES || tagsSizeLong > bb.remaining()) {
+            throw new IllegalArgumentException("Bad ANS-104 tags_size: " + tagsSizeLong + ", remaining=" + bb.remaining());
+        }
+        this.rawTags = readExact(bb, (int) tagsSizeLong, "tags");
+        this.tags = Collections.unmodifiableList(parseAvroTags(rawTags, tagsCount));
+        this.data = new byte[bb.remaining()];
+        bb.get(this.data);
+        this.rawBytes = Arrays.copyOf(bytes, bytes.length);
+        this.id = sha256(signature);
+    }
+
+    public int signatureType() { return signatureType; }
+    public byte[] signature64() { return Arrays.copyOf(signature, signature.length); }
+    public byte[] owner32() { return Arrays.copyOf(owner, owner.length); }
+    public byte[] target() { return Arrays.copyOf(target, target.length); }
+    public byte[] anchor() { return Arrays.copyOf(anchor, anchor.length); }
+    public long tagsCount() { return tagsCount; }
+    public byte[] rawTags() { return Arrays.copyOf(rawTags, rawTags.length); }
+    public List<Tag> tags() { return tags; }
+    public byte[] data() { return Arrays.copyOf(data, data.length); }
+    public byte[] rawBytes() { return Arrays.copyOf(rawBytes, rawBytes.length); }
+    public byte[] id32() { return Arrays.copyOf(id, id.length); }
+
+    public String tagValue(String name) {
+        if (name == null) return null;
+        for (Tag tag : tags) {
+            if (name.equals(tag.name())) return tag.value();
+        }
+        return null;
+    }
+
+    public boolean hasTag(String name, String value) {
+        for (Tag tag : tags) {
+            if (Objects.equals(name, tag.name()) && Objects.equals(value, tag.value())) return true;
+        }
+        return false;
+    }
+
+    public boolean verifySignature() {
+        return Ed25519Util.verify(signingMessage(), signature, owner);
+    }
+
+    public boolean ownerEquals(byte[] expectedOwner32) {
+        return expectedOwner32 != null && expectedOwner32.length == OWNER_LEN && Arrays.equals(owner, expectedOwner32);
+    }
+
+    public byte[] signingMessage() {
+        return buildSigningMessage(owner, target, anchor, tags, data);
+    }
+
+    /**
+     * Builds the exact ANS-104 signing message for generic Ed25519 DataItems.
+     * Useful for SHiNE clients/tests that must sign a DataItem before serializing it.
+     */
+    public static byte[] buildSigningMessage(byte[] owner32, List<Tag> tags, byte[] data) {
+        return buildSigningMessage(owner32, new byte[0], new byte[0], tags, data);
+    }
+
+    public static byte[] buildSigningMessage(byte[] owner32, byte[] target, byte[] anchor, List<Tag> tags, byte[] data) {
+        requireLen(owner32, OWNER_LEN, "owner");
+        byte[] safeTarget = target == null ? new byte[0] : Arrays.copyOf(target, target.length);
+        byte[] safeAnchor = anchor == null ? new byte[0] : Arrays.copyOf(anchor, anchor.length);
+        if (!(safeTarget.length == 0 || safeTarget.length == OPTIONAL_FIELD_LEN)) {
+            throw new IllegalArgumentException("target must be empty or 32 bytes");
+        }
+        if (!(safeAnchor.length == 0 || safeAnchor.length == OPTIONAL_FIELD_LEN)) {
+            throw new IllegalArgumentException("anchor must be empty or 32 bytes");
+        }
+        List<Tag> safeTags = validateTags(tags);
+        byte[] safeData = data == null ? new byte[0] : Arrays.copyOf(data, data.length);
+
+        byte[] rawTags = serializeAvroTags(safeTags);
+        return deepHash(List.of(
+                utf8("dataitem"),
+                utf8("1"),
+                utf8(Integer.toString(SIGNATURE_TYPE_ED25519)),
+                Arrays.copyOf(owner32, owner32.length),
+                safeTarget,
+                safeAnchor,
+                rawTags,
+                safeData
+        ));
+    }
+
+    /** Serialize one SHiNE-ready ANS-104 DataItem with empty target/anchor. */
+    public static byte[] serializeEd25519(byte[] signature64, byte[] owner32, List<Tag> tags, byte[] data) {
+        requireLen(signature64, SIGNATURE_LEN, "signature");
+        requireLen(owner32, OWNER_LEN, "owner");
+        List<Tag> safeTags = validateTags(tags);
+        byte[] rawTags = serializeAvroTags(safeTags);
+        byte[] safeData = data == null ? new byte[0] : data;
+
+        ByteArrayOutputStream out = new ByteArrayOutputStream(
+                2 + SIGNATURE_LEN + OWNER_LEN + 1 + 1 + 8 + 8 + rawTags.length + safeData.length);
+        writeU16LE(out, SIGNATURE_TYPE_ED25519);
+        out.writeBytes(signature64);
+        out.writeBytes(owner32);
+        out.write(0); // target absent
+        out.write(0); // anchor absent
+        writeU64LE(out, safeTags.size());
+        writeU64LE(out, rawTags.length);
+        out.writeBytes(rawTags);
+        out.writeBytes(safeData);
+        return out.toByteArray();
+    }
+
+    private static byte[] readOptional32(ByteBuffer bb, String name) {
+        if (!bb.hasRemaining()) throw new IllegalArgumentException("Missing " + name + " presence byte");
+        int present = Byte.toUnsignedInt(bb.get());
+        if (present == 0) return new byte[0];
+        if (present != 1) throw new IllegalArgumentException("Bad " + name + " presence byte: " + present);
+        return readExact(bb, OPTIONAL_FIELD_LEN, name);
+    }
+
+    private static byte[] readExact(ByteBuffer bb, int len, String field) {
+        if (len < 0 || bb.remaining() < len) {
+            throw new IllegalArgumentException("ANS-104 " + field + " truncated: need=" + len + " remaining=" + bb.remaining());
+        }
+        byte[] out = new byte[len];
+        bb.get(out);
+        return out;
+    }
+
+    private static long readUnsignedLongAsNonNegative(ByteBuffer bb, String field) {
+        if (bb.remaining() < 8) throw new IllegalArgumentException("Missing ANS-104 " + field);
+        long v = bb.getLong();
+        if (v < 0) throw new IllegalArgumentException("ANS-104 " + field + " exceeds signed long range");
+        return v;
+    }
+
+    private static List<Tag> validateTags(List<Tag> tags) {
+        List<Tag> safe = tags == null ? List.of() : List.copyOf(tags);
+        if (safe.size() > MAX_TAGS_COUNT) {
+            throw new IllegalArgumentException("Too many ANS-104 tags: " + safe.size());
+        }
+        for (Tag tag : safe) {
+            if (tag == null || tag.name() == null || tag.value() == null || tag.name().isEmpty() || tag.value().isEmpty()) {
+                throw new IllegalArgumentException("ANS-104 tag name/value must be non-empty");
+            }
+            if (utf8(tag.name()).length > 1024) throw new IllegalArgumentException("ANS-104 tag name exceeds 1024 bytes");
+            if (utf8(tag.value()).length > 3072) throw new IllegalArgumentException("ANS-104 tag value exceeds 3072 bytes");
+        }
+        return safe;
+    }
+
+    private static byte[] serializeAvroTags(List<Tag> tags) {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        if (!tags.isEmpty()) {
+            writeAvroLong(out, tags.size());
+            for (Tag tag : tags) {
+                writeAvroString(out, tag.name());
+                writeAvroString(out, tag.value());
+            }
+        }
+        writeAvroLong(out, 0); // array terminator; also the complete encoding for an empty array
+        byte[] raw = out.toByteArray();
+        if (raw.length > MAX_TAGS_BYTES) throw new IllegalArgumentException("ANS-104 tags exceed " + MAX_TAGS_BYTES + " bytes");
+        return raw;
+    }
+
+    private static void writeAvroString(ByteArrayOutputStream out, String value) {
+        byte[] bytes = utf8(value);
+        writeAvroLong(out, bytes.length);
+        out.writeBytes(bytes);
+    }
+
+    private static void writeAvroLong(ByteArrayOutputStream out, long value) {
+        long n = (value << 1) ^ (value >> 63);
+        while ((n & ~0x7fL) != 0) {
+            out.write((int) ((n & 0x7f) | 0x80));
+            n >>>= 7;
+        }
+        out.write((int) n);
+    }
+
+    private static void writeU16LE(ByteArrayOutputStream out, int value) {
+        out.write(value & 0xff);
+        out.write((value >>> 8) & 0xff);
+    }
+
+    private static void writeU64LE(ByteArrayOutputStream out, long value) {
+        for (int i = 0; i < 8; i++) out.write((int) ((value >>> (8 * i)) & 0xff));
+    }
+
+    private static void requireLen(byte[] bytes, int expected, String name) {
+        if (bytes == null || bytes.length != expected) {
+            throw new IllegalArgumentException(name + " must be " + expected + " bytes");
+        }
+    }
+
+    private static List<Tag> parseAvroTags(byte[] raw, long declaredCount) {
+        AvroCursor c = new AvroCursor(raw);
+        List<Tag> out = new ArrayList<>();
+        while (!c.eof()) {
+            long count = c.readLong();
+            if (count == 0) break;
+            if (count < 0) {
+                count = -count;
+                long blockBytes = c.readLong();
+                if (blockBytes < 0) throw new IllegalArgumentException("Negative Avro tag block size");
+            }
+            if (count > MAX_TAGS_COUNT || out.size() + count > MAX_TAGS_COUNT) {
+                throw new IllegalArgumentException("Too many Avro tags");
+            }
+            for (long i = 0; i < count; i++) {
+                String name = c.readString();
+                String value = c.readString();
+                if (name.isEmpty() || value.isEmpty()) throw new IllegalArgumentException("ANS-104 tag name/value must be non-empty");
+                if (name.getBytes(StandardCharsets.UTF_8).length > 1024) throw new IllegalArgumentException("ANS-104 tag name exceeds 1024 bytes");
+                if (value.getBytes(StandardCharsets.UTF_8).length > 3072) throw new IllegalArgumentException("ANS-104 tag value exceeds 3072 bytes");
+                out.add(new Tag(name, value));
+            }
+        }
+        if (!c.eof()) {
+            throw new IllegalArgumentException("Trailing bytes in ANS-104 Avro tags");
+        }
+        if (out.size() != declaredCount) {
+            throw new IllegalArgumentException("ANS-104 tags_count mismatch: declared=" + declaredCount + " parsed=" + out.size());
+        }
+        return out;
+    }
+
+    private static final class AvroCursor {
+        private final byte[] data;
+        private int p;
+        private AvroCursor(byte[] data) { this.data = data == null ? new byte[0] : data; }
+        boolean eof() { return p == data.length; }
+        long readLong() {
+            long raw = 0;
+            int shift = 0;
+            while (true) {
+                if (p >= data.length) throw new IllegalArgumentException("Truncated Avro long");
+                int b = data[p++] & 0xff;
+                raw |= (long) (b & 0x7f) << shift;
+                if ((b & 0x80) == 0) break;
+                shift += 7;
+                if (shift > 63) throw new IllegalArgumentException("Avro long too large");
+            }
+            return (raw >>> 1) ^ -(raw & 1L);
+        }
+        String readString() {
+            long len = readLong();
+            if (len < 0 || len > Integer.MAX_VALUE || p + len > data.length) {
+                throw new IllegalArgumentException("Bad Avro string length: " + len);
+            }
+            String s = new String(data, p, (int) len, StandardCharsets.UTF_8);
+            p += (int) len;
+            return s;
+        }
+    }
+
+    private static byte[] deepHash(Object item) {
+        if (item instanceof byte[] bytes) {
+            return deepHashBlob(bytes);
+        }
+        if (item instanceof List<?> items) {
+            byte[] acc = sha384(utf8("list" + items.size()));
+            for (Object child : items) {
+                acc = sha384(concat(acc, deepHash(child)));
+            }
+            return acc;
+        }
+        throw new IllegalArgumentException("Unsupported deepHash item: " + (item == null ? "null" : item.getClass()));
+    }
+
+    private static byte[] deepHashBlob(byte[] bytes) {
+        byte[] tag = utf8("blob" + bytes.length);
+        return sha384(concat(sha384(tag), sha384(bytes)));
+    }
+
+    private static byte[] utf8(String s) { return s.getBytes(StandardCharsets.UTF_8); }
+    private static byte[] sha256(byte[] b) { return digest("SHA-256", b); }
+    private static byte[] sha384(byte[] b) { return digest("SHA-384", b); }
+    private static byte[] digest(String alg, byte[] b) {
+        try { return MessageDigest.getInstance(alg).digest(b); }
+        catch (Exception e) { throw new IllegalStateException(alg + " unavailable", e); }
+    }
+    private static byte[] concat(byte[] a, byte[] b) {
+        ByteArrayOutputStream out = new ByteArrayOutputStream(a.length + b.length);
+        out.writeBytes(a); out.writeBytes(b); return out.toByteArray();
+    }
+}

SHiNE-server/shine-server-blockchain/src/main/java/blockchain/BchBlockEntry.java

@@ -9,363 +9,115 @@ import java.util.Arrays;
 import java.util.Objects;
 
 /**
- * BchBlockEntry — универсальный блок формата SHiNE (Frame v0).
+ * SHiNE user block, Frame v1, carried as the data payload of an ANS-104 DataItem.
  *
- * =========================================================================
- *  FRAME v0 — ФИКСИРОВАННЫЙ ФОРМАТ БЛОКА (ДОКУМЕНТ ПРОТОКОЛА)
- * =========================================================================
+ * The constructor accepts the complete serialized ANS-104 DataItem because this is
+ * exactly what is stored in PostgreSQL and exchanged between servers.
  *
- * Все числа BigEndian.
+ * SHiNE Frame v1 (all integer fields BigEndian):
+ *   [2]  frameCode = 0x0001
+ *   [32] prevHash32 = SHA-256(Frame v1 bytes of previous SHiNE block)
+ *   [4]  blockSize = exact Frame v1 byte length
+ *   [4]  blockNumber
+ *   [8]  timestamp unix seconds
+ *   [2]  type
+ *   [2]  subType
+ *   [2]  version
+ *   [N]  bodyBytes
  *
- * PREIMAGE (входит в blockSize, подписывается):
- *   [2]  frameCode        (uint16)   код/версия рамки:
- *                                     - 0x0000 = Frame v0 (текущий)
- *   [32] prevHash32       (bytes)    SHA-256(preimage) предыдущего блока (цепочка)
- *   [4]  blockSize        (int32)    размер preimage (в байтах), ВКЛЮЧАЯ frameCode,
- *                                   НО БЕЗ sigMarker и БЕЗ signature64
- *   [4]  blockNumber      (int32)    глобальный номер блока (>=0)
- *   [8]  timestamp        (int64)    unix seconds
- *   [2]  type             (uint16)   тип сообщения
- *   [2]  subType          (uint16)   подтип сообщения
- *   [2]  version          (uint16)   версия формата сообщения
- *   [N]  bodyBytes        (bytes)    тело сообщения (БЕЗ type/subType/version)
- *
- * TAIL (НЕ входит в blockSize, НЕ подписывается в Frame v0):
- *   [2]  sigMarker        (uint16)   маркер подписи:
- *                                     - 0x0100 (256) = далее подпись Ed25519 64 байта
- *   [64] signature64      (bytes)    Ed25519 signature над hash32
- *
- * hash32 НЕ хранится в блоке.
- * hash32 вычисляется при парсинге:
- *   preimage = первые blockSize байт
- *   hash32   = SHA-256(preimage)
- *
- * Правила MVP-парсера (Frame v0):
- *  - frameCode должен быть строго 0x0000, иначе REJECT.
- *  - sigMarker должен быть строго 0x0100, иначе REJECT.
- *  - подпись обязана присутствовать всегда (sigMarker+signature64).
- *  - НИКАКИХ fallback-веток “если маркер другой, то подписи нет/другой хвост”.
- *
- * Важно по безопасности:
- *  - sigMarker в v0 не входит в подписываемые байты → его можно подменить,
- *    поэтому единственная безопасная логика: "если не 0x0100 — reject".
- * =========================================================================
+ * The user signature is NOT stored in this frame. It is the single Ed25519/Solana
+ * signature of the surrounding ANS-104 DataItem.
  */
 public final class BchBlockEntry {
-
-    public static final int SIGNATURE_LEN = 64;
     public static final int HASH_LEN = 32;
-
-    public static final int FRAME_CODE_LEN = 2;
-    public static final int SIG_MARKER_LEN = 2;
-
-    /** Frame v0 */
-    public static final int FRAME_CODE_V0 = 0x0000;
-
-    /** sigMarker: 256 = 0x0100 */
-    public static final int SIG_MARKER_ED25519 = 0x0100;
-
-    /**
-     * Максимальный допустимый размер блока (fullBytes = preimage + sigMarker + signature),
-     * чтобы не уложить сервер по памяти/диску.
-     */
-    public static final int MAX_BLOCK_FULL_BYTES = 4 * 1024 * 1024;
-
-    /**
-     * Насколько блок может “обгонять” текущее время (защита от кривых часов/вбросов).
-     * Если timestamp больше now + 60 сек — блок считаем неверным.
-     */
+    public static final 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;
 
-    /**
-     * Размер фиксированной части PREIMAGE (без bodyBytes).
-     *
-     * PREIMAGE header:
-     *   frameCode(2) + prevHash32(32) + blockSize(4) + blockNumber(4) + timestamp(8)
-     *   + type(2) + subType(2) + version(2)
-     */
-    public static final int PREIMAGE_HEADER_SIZE =
-            2   // frameCode
-            + 32 // prevHash32
-            + 4  // blockSize
-            + 4  // blockNumber
-            + 8  // timestamp
-            + 2  // type
-            + 2  // subType
-            + 2; // version
-
-    /** Минимальный полный размер блока (без bodyBytes). */
-    public static final int MIN_FULL_BYTES =
-            PREIMAGE_HEADER_SIZE + SIG_MARKER_LEN + SIGNATURE_LEN;
-
-    // --- HEADER (PREIMAGE) ---
-    public final int frameCode;        // uint16 (v0=0)
-    public final byte[] prevHash32;    // 32
-    public final int blockSize;        // preimage size (включая frameCode)
-    public final int blockNumber;      // >=0
+    public final int frameCode;
+    public final byte[] prevHash32;
+    public final int blockSize;
+    public final int blockNumber;
     public final long timestamp;
     public final short type;
     public final short subType;
     public final short version;
-
-    // --- BODY (PREIMAGE) ---
     public final byte[] bodyBytes;
-
-    /** Распарсенное тело (создаётся сразу при парсинге блока). */
     public final BodyRecord body;
 
-    // --- TAIL ---
-    public final int sigMarker;        // uint16 (v0: 0x0100)
-    private final byte[] signature64;  // 64
+    private final Ans104DataItem dataItem;
+    private final byte[] frameBytes;
+    private final byte[] hash32;
 
-    // --- derived ---
-    private final byte[] hash32;       // 32, computed
-    private final byte[] preimage;     // blockSize bytes
-    private final byte[] fullBytes;    // preimage + sigMarker + signature
-
-    /* ===================================================================== */
-    /* ====================== Конструктор из байт ========================== */
-    /* ===================================================================== */
-
-    public BchBlockEntry(byte[] fullBytes) {
-        Objects.requireNonNull(fullBytes, "fullBytes == null");
-
-        if (fullBytes.length < MIN_FULL_BYTES) {
-            throw new IllegalArgumentException("Block too short: " + fullBytes.length + " < " + MIN_FULL_BYTES);
-        }
-        if (fullBytes.length > MAX_BLOCK_FULL_BYTES) {
-            throw new IllegalArgumentException("Block too large: " + fullBytes.length + " > " + MAX_BLOCK_FULL_BYTES);
+    /** Parse a complete serialized ANS-104 DataItem containing one SHiNE Frame v1. */
+    public BchBlockEntry(byte[] fullDataItemBytes) {
+        Objects.requireNonNull(fullDataItemBytes, "fullDataItemBytes == null");
+        this.dataItem = new Ans104DataItem(fullDataItemBytes);
+        this.frameBytes = dataItem.data();
+        if (frameBytes.length < FRAME_HEADER_SIZE) {
+            throw new IllegalArgumentException("SHiNE Frame v1 too short: " + frameBytes.length);
         }
 
-        ByteBuffer bb = ByteBuffer.wrap(fullBytes).order(ByteOrder.BIG_ENDIAN);
-
-        // [2] frameCode
+        ByteBuffer bb = ByteBuffer.wrap(frameBytes).order(ByteOrder.BIG_ENDIAN);
         this.frameCode = Short.toUnsignedInt(bb.getShort());
-        if (this.frameCode != FRAME_CODE_V0) {
-            throw new IllegalArgumentException(String.format(
-                    "Bad frameCode: 0x%04X (expected 0x%04X)", this.frameCode, FRAME_CODE_V0
-            ));
+        if (frameCode != FRAME_CODE_V1) {
+            throw new IllegalArgumentException(String.format("Bad SHiNE frameCode: 0x%04X (expected 0x%04X)", frameCode, FRAME_CODE_V1));
         }
-
-        // [32] prevHash32
         this.prevHash32 = new byte[32];
-        bb.get(this.prevHash32);
-
-        // [4] blockSize
+        bb.get(prevHash32);
         this.blockSize = bb.getInt();
-        if (blockSize < PREIMAGE_HEADER_SIZE) {
-            throw new IllegalArgumentException("blockSize too small: " + blockSize + " < " + PREIMAGE_HEADER_SIZE);
+        if (blockSize != frameBytes.length || blockSize < FRAME_HEADER_SIZE) {
+            throw new IllegalArgumentException("SHiNE blockSize mismatch: declared=" + blockSize + " actual=" + frameBytes.length);
         }
-
-        // fullLen must match exactly: blockSize + sigMarker(2) + signature(64)
-        int expectedFullLen = blockSize + SIG_MARKER_LEN + SIGNATURE_LEN;
-        if (expectedFullLen != fullBytes.length) {
-            throw new IllegalArgumentException("blockSize mismatch: blockSize=" + blockSize
-                    + " expectedFullLen=" + expectedFullLen
-                    + " fullLen=" + fullBytes.length);
-        }
-        if (expectedFullLen > MAX_BLOCK_FULL_BYTES) {
-            throw new IllegalArgumentException("Block too large by blockSize: " + expectedFullLen + " > " + MAX_BLOCK_FULL_BYTES);
-        }
-
-        // [4] blockNumber
         this.blockNumber = bb.getInt();
-        if (this.blockNumber < 0) {
-            throw new IllegalArgumentException("blockNumber < 0: " + this.blockNumber);
-        }
-
-        // [8] timestamp
+        if (blockNumber < 0) throw new IllegalArgumentException("blockNumber < 0: " + blockNumber);
         this.timestamp = bb.getLong();
-
-        // запрет “в будущее” больше чем на 1 минуту
         long now = Instant.now().getEpochSecond();
-        if (this.timestamp > now + MAX_FUTURE_SECONDS) {
-            throw new IllegalArgumentException("timestamp is too far in future: ts=" + this.timestamp
-                    + " now=" + now + " maxFutureSec=" + MAX_FUTURE_SECONDS);
+        if (timestamp > now + MAX_FUTURE_SECONDS) {
+            throw new IllegalArgumentException("timestamp is too far in future: ts=" + timestamp + " now=" + now);
         }
-
-        // [2][2][2] type/subType/version
         this.type = bb.getShort();
         this.subType = bb.getShort();
         this.version = bb.getShort();
-
-        // [N] bodyBytes
-        int bodyLen = blockSize - PREIMAGE_HEADER_SIZE;
-        if (bodyLen < 0) {
-            throw new IllegalArgumentException("Invalid body length: " + bodyLen);
-        }
-        this.bodyBytes = new byte[bodyLen];
-        bb.get(this.bodyBytes);
-
-        // TAIL: [2] sigMarker
-        this.sigMarker = Short.toUnsignedInt(bb.getShort());
-        if (this.sigMarker != SIG_MARKER_ED25519) {
-            throw new IllegalArgumentException(String.format(
-                    "Bad sigMarker: 0x%04X (expected 0x%04X)", this.sigMarker, SIG_MARKER_ED25519
-            ));
-        }
-
-        // TAIL: [64] signature64
-        this.signature64 = new byte[SIGNATURE_LEN];
-        bb.get(this.signature64);
-
-        // preimage = первые blockSize байт (включая frameCode)
-        this.preimage = Arrays.copyOfRange(fullBytes, 0, blockSize);
-
-        // hash32 = sha256(preimage)
-        this.hash32 = BchCryptoVerifier.sha256(preimage);
-
-        // parse body по header.type/subType/version + ОБЯЗАТЕЛЬНЫЙ check()
-        this.body = BodyRecordParser.parse(this.type, this.subType, this.version, this.bodyBytes);
-
-        this.fullBytes = Arrays.copyOf(fullBytes, fullBytes.length);
-
-        if (bb.remaining() != 0) {
-            throw new IllegalArgumentException("Unexpected tail bytes, remaining=" + bb.remaining());
-        }
+        this.bodyBytes = new byte[bb.remaining()];
+        bb.get(bodyBytes);
+        this.body = BodyRecordParser.parse(type, subType, version, bodyBytes);
+        this.hash32 = BchCryptoVerifier.sha256(frameBytes);
     }
 
-    /* ===================================================================== */
-    /* ====================== Конструктор сборки ============================ */
-    /* ===================================================================== */
-
-    public BchBlockEntry(byte[] prevHash32,
-                         int blockNumber,
-                         long timestamp,
-                         short type,
-                         short subType,
-                         short version,
-                         byte[] bodyBytes,
-                         byte[] signature64) {
-
-        Objects.requireNonNull(prevHash32, "prevHash32 == null");
-        Objects.requireNonNull(bodyBytes, "bodyBytes == null");
-        Objects.requireNonNull(signature64, "signature64 == null");
-
-        if (prevHash32.length != 32) throw new IllegalArgumentException("prevHash32 != 32");
-        if (signature64.length != SIGNATURE_LEN) throw new IllegalArgumentException("signature64 != 64");
-
-        if (blockNumber < 0) {
-            throw new IllegalArgumentException("blockNumber < 0: " + blockNumber);
-        }
-
-        // запрет “в будущее” больше чем на 1 минуту
-        long now = Instant.now().getEpochSecond();
-        if (timestamp > now + MAX_FUTURE_SECONDS) {
-            throw new IllegalArgumentException("timestamp is too far in future: ts=" + timestamp
-                    + " now=" + now + " maxFutureSec=" + MAX_FUTURE_SECONDS);
-        }
-
-        this.frameCode = FRAME_CODE_V0;
-        this.prevHash32 = Arrays.copyOf(prevHash32, 32);
-        this.blockNumber = blockNumber;
-        this.timestamp = timestamp;
-        this.type = type;
-        this.subType = subType;
-        this.version = version;
-        this.bodyBytes = Arrays.copyOf(bodyBytes, bodyBytes.length);
-
-        // blockSize = размер preimage (включая frameCode)
-        this.blockSize = PREIMAGE_HEADER_SIZE + this.bodyBytes.length;
-
-        int fullLen = this.blockSize + SIG_MARKER_LEN + SIGNATURE_LEN;
-        if (fullLen > MAX_BLOCK_FULL_BYTES) {
-            throw new IllegalArgumentException("Block too large: " + fullLen + " > " + MAX_BLOCK_FULL_BYTES);
-        }
-
-        // parse body по header + ОБЯЗАТЕЛЬНЫЙ check()
-        this.body = BodyRecordParser.parse(this.type, this.subType, this.version, this.bodyBytes);
-
-        // tail marker фиксирован
-        this.sigMarker = SIG_MARKER_ED25519;
-        this.signature64 = Arrays.copyOf(signature64, SIGNATURE_LEN);
-
-        // build preimage
-        ByteBuffer pre = ByteBuffer.allocate(blockSize).order(ByteOrder.BIG_ENDIAN);
-        pre.putShort((short) (FRAME_CODE_V0 & 0xFFFF));
-        pre.put(this.prevHash32);
-        pre.putInt(this.blockSize);
-        pre.putInt(this.blockNumber);
-        pre.putLong(this.timestamp);
-        pre.putShort(this.type);
-        pre.putShort(this.subType);
-        pre.putShort(this.version);
-        pre.put(this.bodyBytes);
-
-        this.preimage = pre.array();
-        this.hash32 = BchCryptoVerifier.sha256(preimage);
-
-        // build fullBytes: preimage + sigMarker + signature64
-        ByteBuffer full = ByteBuffer.allocate(fullLen).order(ByteOrder.BIG_ENDIAN);
-        full.put(this.preimage);
-        full.putShort((short) (SIG_MARKER_ED25519 & 0xFFFF));
-        full.put(this.signature64);
-        this.fullBytes = full.array();
-    }
-
-    /* ===================================================================== */
-    /* ============================ Getters ================================= */
-    /* ===================================================================== */
-
-    public byte[] getPreimageBytes() {
-        return Arrays.copyOf(preimage, preimage.length);
-    }
-
-    /** Возвращает подпись Ed25519 (64 байта). */
-    public byte[] getSignature64() {
-        return Arrays.copyOf(signature64, SIGNATURE_LEN);
-    }
-
-    /** Возвращает hash32 = SHA-256(preimage). */
-    public byte[] getHash32() {
-        return Arrays.copyOf(hash32, HASH_LEN);
-    }
-
-    /** Возвращает полный блок: preimage + sigMarker + signature. */
-    public byte[] toBytes() {
-        return Arrays.copyOf(fullBytes, fullBytes.length);
-    }
+    public Ans104DataItem getDataItem() { return dataItem; }
+    public byte[] getFrameBytes() { return Arrays.copyOf(frameBytes, frameBytes.length); }
+    /** Kept as an alias for code/docs that called the old field preimage. */
+    public byte[] getPreimageBytes() { return getFrameBytes(); }
+    public byte[] getSignature64() { return dataItem.signature64(); }
+    public byte[] getOwner32() { return dataItem.owner32(); }
+    public byte[] getDataItemId32() { return dataItem.id32(); }
+    public byte[] getHash32() { return Arrays.copyOf(hash32, hash32.length); }
+    /** Full serialized ANS-104 DataItem. */
+    public byte[] toBytes() { return dataItem.rawBytes(); }
 
     @Override
     public String toString() {
-        String timeIso;
-        try {
-            timeIso = Instant.ofEpochSecond(timestamp).toString();
-        } catch (Exception e) {
-            timeIso = "некорректныйTimestamp";
-        }
-
-        return "BchBlockEntry{"
-                + "FRAME{frameCode=0x" + hex4(frameCode)
-                + "}, HDR{"
-                + "blockSize=" + blockSize
-                + ", blockNumber=" + blockNumber
-                + ", timestamp=" + timestamp + " (" + timeIso + ")"
-                + ", type=" + (type & 0xFFFF)
-                + ", subType=" + (subType & 0xFFFF)
-                + ", version=" + (version & 0xFFFF)
-                + ", prevHash32(hex)=" + toHex(prevHash32)
-                + "}"
-                + ", BODY{len=" + (bodyBytes == null ? -1 : bodyBytes.length) + "}"
-                + ", TAIL{sigMarker=0x" + hex4(sigMarker) + ", signature64(hex)=" + toHex(signature64) + "}"
-                + ", DERIVED{hash32(hex)=" + toHex(hash32) + "}"
-                + "}";
-    }
-
-    private static String hex4(int v) {
-        String s = Integer.toHexString(v & 0xFFFF);
-        while (s.length() < 4) s = "0" + s;
-        return s;
+        return "BchBlockEntry{" +
+                "frameCode=0x" + Integer.toHexString(frameCode) +
+                ", blockNumber=" + blockNumber +
+                ", timestamp=" + timestamp +
+                ", type=" + (type & 0xffff) +
+                ", subType=" + (subType & 0xffff) +
+                ", version=" + (version & 0xffff) +
+                ", bodyLen=" + bodyBytes.length +
+                ", dataItemId=" + toHex(getDataItemId32()) +
+                ", blockHash=" + toHex(hash32) +
+                '}';
     }
 
     private static String toHex(byte[] bytes) {
-        if (bytes == null) return "null";
-        char[] HEX = "0123456789abcdef".toCharArray();
+        char[] h = "0123456789abcdef".toCharArray();
         char[] out = new char[bytes.length * 2];
         for (int i = 0; i < bytes.length; i++) {
-            int vv = bytes[i] & 0xFF;
-            out[i * 2] = HEX[vv >>> 4];
-            out[i * 2 + 1] = HEX[vv & 0x0F];
+            int v = bytes[i] & 0xff;
+            out[i * 2] = h[v >>> 4]; out[i * 2 + 1] = h[v & 15];
         }
         return new String(out);
     }

SHiNE-server/shine-server-blockchain/src/main/java/blockchain/BchCryptoVerifier.java

@@ -1,42 +1,27 @@
 package blockchain;
 
-import utils.crypto.Ed25519Util;
-
 import java.security.MessageDigest;
 import java.util.Objects;
 
-/**
- * Верификатор SHiNE (Frame v0):
- *
- * preimage = первые blockSize байт блока (ВКЛЮЧАЯ frameCode=0x0000),
- *          = всё до TAIL (sigMarker+signature).
- *
- * hash32   = SHA-256(preimage)
- * verify   = Ed25519.verify(hash32, signature64, pubKey32)
- */
+/** Cryptographic checks for SHiNE Frame v1 + surrounding ANS-104 DataItem. */
 public final class BchCryptoVerifier {
-
     private BchCryptoVerifier() {}
 
     public static byte[] sha256(byte[] data) {
         Objects.requireNonNull(data, "data == null");
-        try {
-            MessageDigest d = MessageDigest.getInstance("SHA-256");
-            return d.digest(data);
-        } catch (Exception e) {
-            throw new IllegalStateException("SHA-256 unavailable", e);
-        }
+        try { return MessageDigest.getInstance("SHA-256").digest(data); }
+        catch (Exception e) { throw new IllegalStateException("SHA-256 unavailable", e); }
     }
 
+    /**
+     * Verifies that the ANS-104 owner is the current blockchain key and that the
+     * ANS-104 Ed25519 signature is valid. The SHiNE block hash itself remains
+     * SHA-256(Frame v1 bytes) and is intentionally independent of Arweave.
+     */
     public static boolean verifyBlock(BchBlockEntry block, byte[] publicKey32) {
         Objects.requireNonNull(block, "block == null");
         Objects.requireNonNull(publicKey32, "publicKey32 == null");
-
         if (publicKey32.length != 32) throw new IllegalArgumentException("publicKey32 != 32");
-
-        byte[] hash32 = block.getHash32();
-        byte[] sig64 = block.getSignature64();
-
-        return Ed25519Util.verify(hash32, sig64, publicKey32);
+        return block.getDataItem().ownerEquals(publicKey32) && block.getDataItem().verifySignature();
     }
 }

SHiNE-server/shine-server-blockchain/src/main/java/utils/files/FileStoreUtil.java

@@ -1,297 +0,0 @@
-package utils.files;
-
-import java.io.IOException;
-import java.nio.file.*;
-import java.util.Objects;
-
-/**
- * ===============================================================
- *  FileStoreUtil — утилита работы с файлами в папке data/.
- *
- *  Теперь поддерживает:
- *   - основной файл блокчейна:       <blockchainName>.bch
- *   - временный файл блокчейна:      <blockchainName>.tmp_bch
- *   - sidecar-файл проверки записи:  <blockchainName>.write_check
- *   - marker-файл записи:            <blockchainName>.write_pending
- *
- *  Важное:
- *   - validateSimpleFileName() запрещает path traversal.
- *   - atomicReplaceBlockchainFile(): пытается сделать ATOMIC_MOVE (если ФС поддерживает),
- *     иначе делает обычный REPLACE_EXISTING move.
- * ===============================================================
- */
-public final class FileStoreUtil {
-
-    /** Базовая папка для хранения всех файлов (создаётся автоматически). */
-    public static final String DATA_DIR_NAME = "data";
-
-    /** Расширение основного файла блокчейна. */
-    public static final String BLOCKCHAIN_FILE_EXTENSION = ".bch";
-
-    /** Расширение временного файла (старое+новое). */
-    public static final String BLOCKCHAIN_TMP_EXTENSION = ".tmp_bch";
-
-    /** Маркер того, что chain сейчас в процессе полного resync. */
-    public static final String BLOCKCHAIN_RESYNC_MARKER_EXTENSION = ".resync_pending";
-
-    /** Marker того, что обычный AddBlock находится в опасной фазе записи. */
-    public static final String BLOCKCHAIN_WRITE_PENDING_MARKER_EXTENSION = ".write_pending";
-
-    /** Sidecar-файл с blockNumber/blockHash для обычного AddBlock. */
-    public static final String BLOCKCHAIN_WRITE_CHECK_EXTENSION = ".write_check";
-
-    private static final FileStoreUtil INSTANCE = new FileStoreUtil();
-
-    private final Path dataDirPath;
-
-    private FileStoreUtil() {
-        this.dataDirPath = Paths.get(DATA_DIR_NAME);
-        ensureDataDirExists();
-    }
-
-    public static FileStoreUtil getInstance() {
-        return INSTANCE;
-    }
-
-    /* ===================================================================== */
-    /* ======================== Базовые операции =========================== */
-    /* ===================================================================== */
-
-    public void newFile(String fileName, byte[] data) {
-        Objects.requireNonNull(data, "data == null");
-        Path target = resolveSafe(fileName);
-        try {
-            Files.write(target, data,
-                    StandardOpenOption.CREATE,
-                    StandardOpenOption.TRUNCATE_EXISTING,
-                    StandardOpenOption.WRITE);
-        } catch (IOException e) {
-            throw new IllegalStateException("Не удалось записать файл: " + target, e);
-        }
-    }
-
-    public void addDataToFile(String fileName, byte[] data) {
-        Objects.requireNonNull(data, "data == null");
-        Path target = resolveSafe(fileName);
-        try {
-            Files.write(target, data,
-                    StandardOpenOption.CREATE,
-                    StandardOpenOption.WRITE,
-                    StandardOpenOption.APPEND);
-        } catch (IOException e) {
-            throw new IllegalStateException("Не удалось дописать файл: " + target, e);
-        }
-    }
-
-    public byte[] readAllDataFromFile(String fileName) {
-        Path target = resolveSafe(fileName);
-        if (!Files.exists(target)) {
-            throw new IllegalStateException("Файл не найден: " + target);
-        }
-        try {
-            return Files.readAllBytes(target);
-        } catch (IOException e) {
-            throw new IllegalStateException("Не удалось прочитать файл: " + target, e);
-        }
-    }
-
-    public boolean exists(String fileName) {
-        Path target = resolveSafe(fileName);
-        return Files.exists(target);
-    }
-
-    public long size(String fileName) {
-        Path target = resolveSafe(fileName);
-        try {
-            return Files.size(target);
-        } catch (IOException e) {
-            throw new IllegalStateException("Не удалось получить размер файла: " + target, e);
-        }
-    }
-
-    /* ===================================================================== */
-    /* ===================== Блокчейн-файлы по имени ======================= */
-    /* ===================================================================== */
-
-    /** <blockchainName>.bch */
-    public String buildBlockchainFileName(String blockchainName) {
-        validateSimpleFileName(blockchainName);
-        return blockchainName + BLOCKCHAIN_FILE_EXTENSION;
-    }
-
-    /** <blockchainName>.tmp_bch */
-    public String buildBlockchainTmpFileName(String blockchainName) {
-        validateSimpleFileName(blockchainName);
-        return blockchainName + BLOCKCHAIN_TMP_EXTENSION;
-    }
-
-    public Path resolveBlockchainPath(String blockchainName) {
-        return resolveSafe(buildBlockchainFileName(blockchainName));
-    }
-
-    public Path resolveBlockchainTmpPath(String blockchainName) {
-        return resolveSafe(buildBlockchainTmpFileName(blockchainName));
-    }
-
-    public byte[] readBlockchain(String blockchainName) {
-        return readAllDataFromFile(buildBlockchainFileName(blockchainName));
-    }
-
-    public void writeBlockchainTmp(String blockchainName, byte[] data) {
-        newFile(buildBlockchainTmpFileName(blockchainName), data);
-    }
-
-    /** <blockchainName>.write_check */
-    public String buildBlockchainWriteCheckFileName(String blockchainName) {
-        validateSimpleFileName(blockchainName);
-        return blockchainName + BLOCKCHAIN_WRITE_CHECK_EXTENSION;
-    }
-
-    public Path resolveBlockchainWriteCheckPath(String blockchainName) {
-        return resolveSafe(buildBlockchainWriteCheckFileName(blockchainName));
-    }
-
-    public void writeBlockchainWriteCheck(String blockchainName, int blockNumber, String blockHashHex) {
-        StringBuilder sb = new StringBuilder(128);
-        sb.append("blockNumber=").append(blockNumber).append('\n');
-        sb.append("blockHash=").append(blockHashHex == null ? "" : blockHashHex).append('\n');
-        newFile(buildBlockchainWriteCheckFileName(blockchainName), sb.toString().getBytes(java.nio.charset.StandardCharsets.UTF_8));
-    }
-
-    /** <blockchainName>.write_pending */
-    public String buildBlockchainWritePendingMarkerFileName(String blockchainName) {
-        validateSimpleFileName(blockchainName);
-        return blockchainName + BLOCKCHAIN_WRITE_PENDING_MARKER_EXTENSION;
-    }
-
-    public Path resolveBlockchainWritePendingMarkerPath(String blockchainName) {
-        return resolveSafe(buildBlockchainWritePendingMarkerFileName(blockchainName));
-    }
-
-    public void writeBlockchainWritePendingMarker(String blockchainName) {
-        newFile(buildBlockchainWritePendingMarkerFileName(blockchainName), new byte[0]);
-    }
-
-    /** <blockchainName>.resync_pending */
-    public String buildBlockchainResyncMarkerFileName(String blockchainName) {
-        validateSimpleFileName(blockchainName);
-        return blockchainName + BLOCKCHAIN_RESYNC_MARKER_EXTENSION;
-    }
-
-    public Path resolveBlockchainResyncMarkerPath(String blockchainName) {
-        return resolveSafe(buildBlockchainResyncMarkerFileName(blockchainName));
-    }
-
-    public void writeBlockchainResyncMarker(String blockchainName, String markerContent) {
-        byte[] data = markerContent == null ? new byte[0] : markerContent.getBytes(java.nio.charset.StandardCharsets.UTF_8);
-        newFile(buildBlockchainResyncMarkerFileName(blockchainName), data);
-    }
-
-    public void deleteIfExists(Path path) {
-        if (path == null) {
-            return;
-        }
-        try {
-            Files.deleteIfExists(path);
-        } catch (IOException e) {
-            throw new IllegalStateException("Не удалось удалить файл: " + path, e);
-        }
-    }
-
-    public void deleteBlockchainFileIfExists(String blockchainName) {
-        deleteIfExists(resolveBlockchainPath(blockchainName));
-    }
-
-    public void deleteBlockchainTmpFileIfExists(String blockchainName) {
-        deleteIfExists(resolveBlockchainTmpPath(blockchainName));
-    }
-
-    public void deleteBlockchainWriteCheckIfExists(String blockchainName) {
-        deleteIfExists(resolveBlockchainWriteCheckPath(blockchainName));
-    }
-
-    public void deleteBlockchainWritePendingMarkerIfExists(String blockchainName) {
-        deleteIfExists(resolveBlockchainWritePendingMarkerPath(blockchainName));
-    }
-
-    public void deleteBlockchainResyncMarkerIfExists(String blockchainName) {
-        deleteIfExists(resolveBlockchainResyncMarkerPath(blockchainName));
-    }
-
-    public boolean existsBlockchainResyncMarker(String blockchainName) {
-        return exists(buildBlockchainResyncMarkerFileName(blockchainName));
-    }
-
-    /**
-     * Атомарно заменить основной файл блокчейна временным:
-     *   <name>.tmp_bch  ->  <name>.bch
-     *
-     * Стратегия:
-     *  1) Пытаемся Files.move(..., ATOMIC_MOVE, REPLACE_EXISTING)
-     *  2) Если ATOMIC_MOVE не поддерживается — делаем move с REPLACE_EXISTING без атомарности
-     *
-     * Важный нюанс:
-     *  - атомарность гарантируется только в пределах одной файловой системы.
-     */
-    public void atomicReplaceBlockchainFile(String blockchainName) {
-        Path tmp = resolveBlockchainTmpPath(blockchainName);
-        Path main = resolveBlockchainPath(blockchainName);
-
-        if (!Files.exists(tmp)) {
-            throw new IllegalStateException("TMP-файл не найден: " + tmp);
-        }
-
-        try {
-            // 1) Пытаемся атомарный move
-            Files.move(tmp, main,
-                    StandardCopyOption.REPLACE_EXISTING,
-                    StandardCopyOption.ATOMIC_MOVE);
-        } catch (AtomicMoveNotSupportedException e) {
-            // 2) Если ФС не поддерживает атомарный move — делаем обычный replace
-            try {
-                Files.move(tmp, main, StandardCopyOption.REPLACE_EXISTING);
-            } catch (IOException ex) {
-                throw new IllegalStateException("Не удалось заменить файл блокчейна (non-atomic): " + main, ex);
-            }
-        } catch (IOException e) {
-            throw new IllegalStateException("Не удалось заменить файл блокчейна (atomic): " + main, e);
-        }
-    }
-
-    /* ===================================================================== */
-    /* ============================ Helpers ================================= */
-    /* ===================================================================== */
-
-    private void ensureDataDirExists() {
-        try {
-            if (!Files.exists(dataDirPath)) {
-                Files.createDirectories(dataDirPath);
-            }
-        } catch (IOException e) {
-            throw new IllegalStateException("Не удалось создать директорию хранения: " + dataDirPath, e);
-        }
-    }
-
-    private Path resolveSafe(String fileName) {
-        validateSimpleFileName(fileName);
-        return dataDirPath.resolve(fileName);
-    }
-
-    /**
-     * Валидация "простого имени":
-     *  - запрещаем слэши, обратные слэши, ".."
-     *  - запрещаем пустоту
-     *
-     * Важно: сюда у нас попадает и blockchainName (как часть имени файла),
-     * поэтому blockchainName должен быть "простым": без путей.
-     */
-    private void validateSimpleFileName(String fileName) {
-        Objects.requireNonNull(fileName, "fileName == null");
-        if (fileName.isBlank()) {
-            throw new IllegalArgumentException("Имя файла не должно быть пустым");
-        }
-        if (fileName.contains("/") || fileName.contains("\\") || fileName.contains("..")) {
-            throw new IllegalArgumentException("Недопустимое имя файла: " + fileName);
-        }
-    }
-}

SHiNE-server/shine-server-blockchain/src/test/java/blockchain/Ans104DataItemTest.java

@@ -0,0 +1,74 @@
+package blockchain;
+
+import org.junit.jupiter.api.Test;
+import utils.crypto.Ed25519Util;
+
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+final class Ans104DataItemTest {
+    @Test
+    void ed25519RoundTripWithTestAndChannelTags() {
+        byte[] privateKey = Ed25519Util.generatePrivateKeyFromString("shine-ans104-test-key");
+        byte[] owner = Ed25519Util.derivePublicKey(privateKey);
+        byte[] data = "frame-v1-test".getBytes(StandardCharsets.UTF_8);
+        List<Ans104DataItem.Tag> tags = List.of(
+                new Ans104DataItem.Tag("App", "test5590"),
+                new Ans104DataItem.Tag("c", "books")
+        );
+
+        byte[] message = Ans104DataItem.buildSigningMessage(owner, tags, data);
+        byte[] signature = Ed25519Util.sign(message, privateKey);
+        byte[] raw = Ans104DataItem.serializeEd25519(signature, owner, tags, data);
+
+        Ans104DataItem parsed = new Ans104DataItem(raw);
+        assertEquals(2, parsed.signatureType());
+        assertArrayEquals(owner, parsed.owner32());
+        assertArrayEquals(data, parsed.data());
+        assertTrue(parsed.hasTag("App", "test5590"));
+        assertEquals("books", parsed.tagValue("c"));
+        assertTrue(parsed.verifySignature());
+        assertEquals(32, parsed.id32().length);
+    }
+
+    @Test
+    void mutationBreaksSignature() {
+        byte[] privateKey = Ed25519Util.generatePrivateKeyFromString("shine-ans104-mutation-key");
+        byte[] owner = Ed25519Util.derivePublicKey(privateKey);
+        byte[] data = "original".getBytes(StandardCharsets.UTF_8);
+        List<Ans104DataItem.Tag> tags = List.of(new Ans104DataItem.Tag("App", "test5590"));
+        byte[] signature = Ed25519Util.sign(Ans104DataItem.buildSigningMessage(owner, tags, data), privateKey);
+        byte[] raw = Ans104DataItem.serializeEd25519(signature, owner, tags, data);
+        raw[raw.length - 1] ^= 1;
+        assertFalse(new Ans104DataItem(raw).verifySignature());
+    }
+    @Test
+    void signingMessageMatchesArbundlesTurboCompatibilityVector() {
+        byte[] owner = new byte[32];
+        for (int i = 0; i < owner.length; i++) owner[i] = (byte) i;
+        byte[] data = "frame-v1-test".getBytes(StandardCharsets.UTF_8);
+        List<Ans104DataItem.Tag> tags = List.of(
+                new Ans104DataItem.Tag("App", "test5590"),
+                new Ans104DataItem.Tag("c", "books")
+        );
+
+        byte[] actual = Ans104DataItem.buildSigningMessage(owner, tags, data);
+        byte[] expected = hex("7e67d0debce103606d697a1e3785130ca20cb89cd8a06f9a65b98b2d2427eaf411fcf7d482da268e44f3ac25c57c3cb9");
+        assertArrayEquals(expected, actual);
+    }
+
+    private static byte[] hex(String value) {
+        if ((value.length() & 1) != 0) throw new IllegalArgumentException("odd hex length");
+        byte[] out = new byte[value.length() / 2];
+        for (int i = 0; i < out.length; i++) {
+            int hi = Character.digit(value.charAt(i * 2), 16);
+            int lo = Character.digit(value.charAt(i * 2 + 1), 16);
+            if (hi < 0 || lo < 0) throw new IllegalArgumentException("bad hex");
+            out[i] = (byte) ((hi << 4) | lo);
+        }
+        return out;
+    }
+
+}

SHiNE-server/shine-server-config/src/main/java/utils/config/AppConfig.java

@@ -66,19 +66,20 @@ public final class AppConfig {
 
     /** Вернёт строку или пустую строку, если параметр не найден. */
     public String getStringOrEmpty(String name) {
-        String value = properties.getProperty(name);
+        String value = getParam(name);
         return value == null ? "" : value.trim();
     }
 
-    /** Можно добавить методы для удобства */
+    /** Целочисленный параметр с тем же приоритетом: system property -> env -> properties. */
     public int getInt(String name, int defaultValue) {
-        String v = properties.getProperty(name);
-        return v == null ? defaultValue : Integer.parseInt(v);
+        String v = getParam(name);
+        return v == null || v.isBlank() ? defaultValue : Integer.parseInt(v.trim());
     }
 
+    /** Boolean-параметр с тем же приоритетом: system property -> env -> properties. */
     public boolean getBoolean(String name, boolean defaultValue) {
-        String v = properties.getProperty(name);
-        return v == null ? defaultValue : Boolean.parseBoolean(v);
+        String v = getParam(name);
+        return v == null || v.isBlank() ? defaultValue : Boolean.parseBoolean(v.trim());
     }
 
     private static String toEnvName(String name) {

SHiNE-server/shine-server-config/src/main/java/utils/config/ShineSignatureConstants.java

@@ -17,6 +17,9 @@ public final class ShineSignatureConstants {
     /** Подписываемые данные пользовательских настроек: prefix + login + type + key + time_ms + value_text + value_num */
     public static final String USER_SETTINGS_PREFIX = "SHiNe/UserSettings:";
 
+    /** Подписанный watermark чтения канала: prefix + login + owner_bch_name + channel_name + time_ms + read_count */
+    public static final String CHANNEL_READ_STATE_PREFIX = "SHiNe/ChannelReadState:";
+
     /** TAG в HeaderBody (genesis). ASCII "SHiNe". */
     public static final String BLOCKCHAIN_HEADER_TAG = "SHiNe";
 

SHiNE-server/shine-server-crypto/src/main/java/utils/crypto/README.md

@@ -1,7 +1,7 @@
 # utils.crypto
 
 Пакет отвечает за криптографию — подписи и хэши блоков.  
-Используется при создании и проверке целостности `.bch`-блоков.
+Используется при создании и проверке криптографических сущностей SHiNE; пользовательские blockchain-файлы `.bch` больше не используются.
 
 ---
 

SHiNE-server/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java

@@ -37,6 +37,10 @@ public final class DatabaseInitializer {
     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 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";
@@ -57,6 +61,10 @@ public final class DatabaseInitializer {
     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";
 
     private DatabaseInitializer() {}
 
@@ -206,6 +214,22 @@ public final class DatabaseInitializer {
                 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;
+            }
         }
     }
 

SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ArweaveBlockImportDAO.java

@@ -0,0 +1,138 @@
+package shine.db.dao;
+
+import shine.db.DbController;
+
+import java.sql.*;
+import java.util.ArrayList;
+import java.util.List;
+
+/** Persistent discovery/import queue for ANS-104 SHiNE blocks found through Arweave. */
+public final class ArweaveBlockImportDAO {
+    public static final String STATUS_PENDING = "PENDING";
+    public static final String STATUS_REJECTED = "REJECTED";
+
+    public record QueueItem(byte[] dataItemId, String rootTxId, long blockHeight,
+                            byte[] rawDataItem, String status, String lastError,
+                            long firstSeenAtMs, long updatedAtMs) {}
+
+    private static volatile ArweaveBlockImportDAO instance;
+    private final DbController db = DbController.getInstance();
+
+    private ArweaveBlockImportDAO() {}
+
+    public static ArweaveBlockImportDAO getInstance() {
+        if (instance == null) {
+            synchronized (ArweaveBlockImportDAO.class) {
+                if (instance == null) instance = new ArweaveBlockImportDAO();
+            }
+        }
+        return instance;
+    }
+
+    public long getLastBlockHeight() throws SQLException {
+        try (Connection c = db.getConnection();
+             PreparedStatement ps = c.prepareStatement("SELECT last_block_height FROM arweave_block_sync_state WHERE id=1");
+             ResultSet rs = ps.executeQuery()) {
+            return rs.next() ? rs.getLong(1) : 0L;
+        }
+    }
+
+    public void setLastBlockHeight(long height, long nowMs) throws SQLException {
+        String sql = """
+            INSERT INTO arweave_block_sync_state(id,last_block_height,updated_at_ms)
+            VALUES(1,?,?)
+            ON CONFLICT(id) DO UPDATE SET last_block_height=EXCLUDED.last_block_height, updated_at_ms=EXCLUDED.updated_at_ms
+            """;
+        try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setLong(1, Math.max(0L, height));
+            ps.setLong(2, nowMs);
+            ps.executeUpdate();
+        }
+    }
+
+    /** Insert once. Existing IDs (including REJECTED) are deliberately not re-enqueued. */
+    public boolean enqueueIfMissing(byte[] dataItemId, String rootTxId, long blockHeight, byte[] rawDataItem, long nowMs)
+            throws SQLException {
+        String sql = """
+            INSERT INTO arweave_block_import_queue(
+                data_item_id,root_tx_id,block_height,raw_data_item,status,last_error,first_seen_at_ms,updated_at_ms
+            ) VALUES(?,?,?,?,?,'',?,?)
+            ON CONFLICT(data_item_id) DO NOTHING
+            """;
+        try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setBytes(1, dataItemId);
+            ps.setString(2, rootTxId);
+            ps.setLong(3, blockHeight);
+            ps.setBytes(4, rawDataItem);
+            ps.setString(5, STATUS_PENDING);
+            ps.setLong(6, nowMs);
+            ps.setLong(7, nowMs);
+            return ps.executeUpdate() > 0;
+        }
+    }
+
+    public boolean exists(byte[] dataItemId) throws SQLException {
+        try (Connection c = db.getConnection();
+             PreparedStatement ps = c.prepareStatement("SELECT 1 FROM arweave_block_import_queue WHERE data_item_id=? LIMIT 1")) {
+            ps.setBytes(1, dataItemId);
+            try (ResultSet rs = ps.executeQuery()) { return rs.next(); }
+        }
+    }
+
+    public List<QueueItem> listPending(int limit) throws SQLException {
+        int safeLimit = Math.max(1, Math.min(limit, 100_000));
+        String sql = """
+            SELECT data_item_id,root_tx_id,block_height,raw_data_item,status,last_error,first_seen_at_ms,updated_at_ms
+            FROM arweave_block_import_queue
+            WHERE status=?
+            ORDER BY block_height ASC, first_seen_at_ms ASC
+            LIMIT ?
+            """;
+        List<QueueItem> out = new ArrayList<>();
+        try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setString(1, STATUS_PENDING);
+            ps.setInt(2, safeLimit);
+            try (ResultSet rs = ps.executeQuery()) {
+                while (rs.next()) {
+                    out.add(new QueueItem(
+                            rs.getBytes("data_item_id"), rs.getString("root_tx_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")));
+                }
+            }
+        }
+        return out;
+    }
+
+    public void setPendingError(byte[] id, String error, long nowMs) throws SQLException {
+        updateStatus(id, STATUS_PENDING, error, nowMs);
+    }
+
+    public void reject(byte[] id, String error, long nowMs) throws SQLException {
+        updateStatus(id, STATUS_REJECTED, error, nowMs);
+    }
+
+    public void delete(byte[] id) throws SQLException {
+        try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(
+                "DELETE FROM arweave_block_import_queue WHERE data_item_id=?")) {
+            ps.setBytes(1, id);
+            ps.executeUpdate();
+        }
+    }
+
+    private void updateStatus(byte[] id, String status, String error, long nowMs) throws SQLException {
+        try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(
+                "UPDATE arweave_block_import_queue SET status=?,last_error=?,updated_at_ms=? WHERE data_item_id=?")) {
+            ps.setString(1, status);
+            ps.setString(2, trimError(error));
+            ps.setLong(3, nowMs);
+            ps.setBytes(4, id);
+            ps.executeUpdate();
+        }
+    }
+
+    private static String trimError(String s) {
+        String v = s == null ? "" : s.replace('\n',' ').replace('\r',' ').trim();
+        return v.length() <= 500 ? v : v.substring(0,500);
+    }
+}

SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlockchainResyncCleanupDAO.java

@@ -23,7 +23,7 @@ import java.sql.SQLException;
  *  - нам нужен один понятный "блок операции", который можно вызвать из resync-flow;
  *  - эта схема проще и прозрачнее, чем много обратных триггеров по разным таблицам;
  *  - если любой шаг не удался, делаем rollback и БД остаётся в исходном состоянии;
- *  - файловые действия (.bch / .tmp_bch) сознательно НЕ входят в эту транзакцию:
+ *  - пользовательские blockchain-файлы больше не существуют; cleanup полностью DB-only.
  *    SQL-транзакция и файловая система не коммитятся атомарно вместе;
  *    поэтому БД-чистка делается здесь, а файловая чистка будет следующим шагом
  *    отдельным recovery/resync-слоем после успешного commit.
@@ -71,7 +71,7 @@ public final class BlockchainResyncCleanupDAO {
      *  - если blockchain_state уже отсутствует, login берём из blockchainName.
      *
      * Отдельно важно:
-     *  - здесь НЕТ удаления .bch/.tmp_bch;
+     *  - filesystem blockchain storage отсутствует;
      *  - здесь НЕТ повторной загрузки цепочки;
      *  - это только атомарная SQL-очистка БД, на которую потом будет опираться resync-flow.
      */

SHiNE-server/shine-server-db/src/main/java/shine/db/dao/BlocksDAO.java

@@ -9,286 +9,147 @@ import java.sql.*;
 import java.util.ArrayList;
 import java.util.List;
 
-/**
- * DAO для таблицы blocks (новый формат).
- *
- * Правило:
- * - методы с Connection НЕ закрывают соединение
- * - методы без Connection сами открывают и закрывают соединение
- *
- * Ключ:
- * - (bch_name, block_number) — уникальная пара в рамках общей БД сервера.
- */
+/** DAO for SHiNE Frame v1 blocks. block_bytes contains the complete ANS-104 DataItem. */
 public final class BlocksDAO {
-
     private static volatile BlocksDAO instance;
     private final DbController db = DbController.getInstance();
     private static final Logger log = LoggerFactory.getLogger(BlocksDAO.class);
 
     private BlocksDAO() { }
-
     public static BlocksDAO getInstance() {
-        if (instance == null) {
-            synchronized (BlocksDAO.class) {
-                if (instance == null) instance = new BlocksDAO();
-            }
-        }
+        if (instance == null) synchronized (BlocksDAO.class) { if (instance == null) instance = new BlocksDAO(); }
         return instance;
     }
 
-    // -------------------- INSERT --------------------
-
-    /** Вставка с внешним соединением. Соединение НЕ закрывает. */
     public void insert(Connection c, BlockEntry e) throws SQLException {
-        log.info("DBG BlockEntry: type={} sub={} lineCode={} prevLineNumber={} thisLineNumber={} prevLineHashLen={}",
-                e.getMsgType(), e.getMsgSubType(),
-                e.getLineCode(), e.getPrevLineNumber(), e.getThisLineNumber(),
-                e.getPrevLineHash() == null ? null : e.getPrevLineHash().length
-        );
-
         String sql = """
             INSERT INTO blocks (
-                login,
-                bch_name,
-                block_number,
-                msg_type,
-                msg_sub_type,
-                block_bytes,
-                to_login,
-                to_bch_name,
-                to_block_number,
-                to_block_hash,
-                block_hash,
-                block_signature,
-                edited_by_block_number,
-                line_code,
-                prev_line_number,
-                prev_line_hash,
-                this_line_number
-            ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+                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,
+                arweave_publish_pending,arweave_published_at_ms,arweave_root_tx_id,
+                edited_by_block_number,line_code,prev_line_number,prev_line_hash,this_line_number
+            ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
             """;
-
         try (PreparedStatement ps = c.prepareStatement(sql)) {
             int i = 1;
-
             ps.setString(i++, e.getLogin());
             ps.setString(i++, e.getBchName());
             ps.setInt(i++, e.getBlockNumber());
-
             ps.setInt(i++, e.getMsgType());
             ps.setInt(i++, e.getMsgSubType());
-
             ps.setBytes(i++, e.getBlockBytes());
-
-            if (e.getToLogin() != null) ps.setString(i++, e.getToLogin());
-            else ps.setNull(i++, Types.VARCHAR);
-
-            if (e.getToBchName() != null) ps.setString(i++, e.getToBchName());
-            else ps.setNull(i++, Types.VARCHAR);
-
-            if (e.getToBlockNumber() != null) ps.setInt(i++, e.getToBlockNumber());
-            else ps.setNull(i++, Types.INTEGER);
-
-            if (e.getToBlockHash() != null) ps.setBytes(i++, e.getToBlockHash());
-            else ps.setNull(i++, Types.BINARY);
-
+            setNullableString(ps, i++, e.getToLogin());
+            setNullableString(ps, i++, e.getToBchName());
+            setNullableInt(ps, i++, e.getToBlockNumber());
+            setNullableBytes(ps, i++, e.getToBlockHash());
             ps.setBytes(i++, e.getBlockHash());
             ps.setBytes(i++, e.getBlockSignature());
-
-            if (e.getEditedByBlockNumber() != null) ps.setInt(i++, e.getEditedByBlockNumber());
-            else ps.setNull(i++, Types.INTEGER);
-
-            // NEW: line_code
-            if (e.getLineCode() != null) ps.setInt(i++, e.getLineCode());
-            else ps.setNull(i++, Types.INTEGER);
-
-            if (e.getPrevLineNumber() != null) ps.setInt(i++, e.getPrevLineNumber());
-            else ps.setNull(i++, Types.INTEGER);
-
-            if (e.getPrevLineHash() != null) ps.setBytes(i++, e.getPrevLineHash());
-            else ps.setNull(i++, Types.BINARY);
-
-            if (e.getThisLineNumber() != null) ps.setInt(i++, e.getThisLineNumber());
-            else ps.setNull(i++, Types.INTEGER);
-
+            ps.setBytes(i++, e.getDataItemId());
+            ps.setBoolean(i++, e.isArweavePublishPending());
+            if (e.getArweavePublishedAtMs() == null) ps.setNull(i++, Types.BIGINT); else ps.setLong(i++, e.getArweavePublishedAtMs());
+            setNullableString(ps, i++, e.getArweaveRootTxId());
+            setNullableInt(ps, i++, e.getEditedByBlockNumber());
+            setNullableInt(ps, i++, e.getLineCode());
+            setNullableInt(ps, i++, e.getPrevLineNumber());
+            setNullableBytes(ps, i++, e.getPrevLineHash());
+            setNullableInt(ps, i++, e.getThisLineNumber());
             ps.executeUpdate();
         }
     }
 
-    /** Вставка без внешнего соединения. Сам открывает/закрывает. */
-    public void insert(BlockEntry e) throws SQLException {
-        try (Connection c = db.getConnection()) {
-            insert(c, e);
+    public void insert(BlockEntry e) throws SQLException { try (Connection c = db.getConnection()) { insert(c, e); } }
+
+    public boolean existsByDataItemId(byte[] dataItemId) throws SQLException {
+        if (dataItemId == null || dataItemId.length != 32) return false;
+        try (Connection c = db.getConnection();
+             PreparedStatement ps = c.prepareStatement("SELECT 1 FROM blocks WHERE data_item_id=? LIMIT 1")) {
+            ps.setBytes(1, dataItemId);
+            try (ResultSet rs = ps.executeQuery()) { return rs.next(); }
         }
     }
 
-    // -------------------- SELECT: HASH BY NUMBER --------------------
-
-    /** Получить block_hash по (bch_name, block_number). Нужен для линейной проверки. */
-    public byte[] getHashByNumber(Connection c, String bchName, int blockNumber) throws SQLException {
+    public List<BlockEntry> listPendingArweave(int limit) throws SQLException {
+        int safeLimit = Math.max(1, Math.min(limit, 100_000));
         String sql = """
-            SELECT block_hash
+            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,
+                   arweave_publish_pending,arweave_published_at_ms,arweave_root_tx_id,
+                   edited_by_block_number,line_code,prev_line_number,prev_line_hash,this_line_number
             FROM blocks
-            WHERE bch_name = ? AND block_number = ?
-            LIMIT 1
+            WHERE arweave_publish_pending = TRUE
+            ORDER BY bch_name ASC, block_number ASC
+            LIMIT ?
             """;
-
-        try (PreparedStatement ps = c.prepareStatement(sql)) {
-            ps.setString(1, bchName);
-            ps.setInt(2, blockNumber);
-            try (ResultSet rs = ps.executeQuery()) {
-                if (!rs.next()) return null;
-                return rs.getBytes("block_hash");
-            }
+        List<BlockEntry> out = new ArrayList<>();
+        try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setInt(1, safeLimit);
+            try (ResultSet rs = ps.executeQuery()) { while (rs.next()) out.add(mapRow(rs)); }
         }
+        return out;
     }
 
-    public byte[] getHashByNumber(String bchName, int blockNumber) throws SQLException {
+    public void markArweavePublished(List<byte[]> dataItemIds, String rootTxId, long publishedAtMs) throws SQLException {
+        if (dataItemIds == null || dataItemIds.isEmpty()) return;
+        String sql = """
+            UPDATE blocks
+            SET arweave_publish_pending=FALSE, arweave_published_at_ms=?, arweave_root_tx_id=?
+            WHERE data_item_id=?
+            """;
         try (Connection c = db.getConnection()) {
-            return getHashByNumber(c, bchName, blockNumber);
+            c.setAutoCommit(false);
+            try (PreparedStatement ps = c.prepareStatement(sql)) {
+                for (byte[] id : dataItemIds) {
+                    ps.setLong(1, publishedAtMs); ps.setString(2, rootTxId); ps.setBytes(3, id); ps.addBatch();
+                }
+                ps.executeBatch(); c.commit();
+            } catch (Exception e) { c.rollback(); throw e; }
+            finally { c.setAutoCommit(true); }
         }
     }
 
-    // -------------------- SELECT: FULL ENTRY --------------------
+    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 (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 = """
-            SELECT
-                login,
-                bch_name,
-                block_number,
-                msg_type,
-                msg_sub_type,
-                block_bytes,
-                to_login,
-                to_bch_name,
-                to_block_number,
-                to_block_hash,
-                block_hash,
-                block_signature,
-                edited_by_block_number,
-                line_code,
-                prev_line_number,
-                prev_line_hash,
-                this_line_number
-            FROM blocks
-            WHERE bch_name = ? AND block_number = ?
-            LIMIT 1
-            """;
+        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;} }
+    }
+    public BlockEntry getByNumber(String bchName,int blockNumber)throws SQLException{try(Connection c=db.getConnection()){return getByNumber(c,bchName,blockNumber);} }
 
-        try (PreparedStatement ps = c.prepareStatement(sql)) {
-            ps.setString(1, bchName);
-            ps.setInt(2, blockNumber);
-
-            try (ResultSet rs = ps.executeQuery()) {
-                if (!rs.next()) return null;
-                return mapRow(rs);
-            }
-        }
+    public List<BlockEntry> listRangeByNumber(String bchName,int from,int to)throws SQLException{try(Connection c=db.getConnection()){return listRangeByNumber(c,bchName,from,to);} }
+    public List<BlockEntry> listRangeByNumber(Connection c,String bchName,int from,int to)throws SQLException{
+        String sql=baseSelect()+" WHERE bch_name=? AND block_number>=? AND block_number<=? ORDER BY block_number ASC";
+        List<BlockEntry> 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));}}
+        return out;
     }
 
-    public BlockEntry getByNumber(String bchName, int blockNumber) throws SQLException {
-        try (Connection c = db.getConnection()) {
-            return getByNumber(c, bchName, blockNumber);
-        }
-    }
-
-    public List<BlockEntry> listRangeByNumber(String bchName, int fromBlockNumberInclusive, int toBlockNumberInclusive) throws SQLException {
-        try (Connection c = db.getConnection()) {
-            return listRangeByNumber(c, bchName, fromBlockNumberInclusive, toBlockNumberInclusive);
-        }
-    }
-
-    public List<BlockEntry> listRangeByNumber(Connection c, String bchName, int fromBlockNumberInclusive, int toBlockNumberInclusive) throws SQLException {
-        String sql = """
-            SELECT
-                login,
-                bch_name,
-                block_number,
-                msg_type,
-                msg_sub_type,
-                block_bytes,
-                to_login,
-                to_bch_name,
-                to_block_number,
-                to_block_hash,
-                block_hash,
-                block_signature,
-                edited_by_block_number,
-                line_code,
-                prev_line_number,
-                prev_line_hash,
-                this_line_number
-            FROM blocks
-            WHERE bch_name = ?
-              AND block_number >= ?
-              AND block_number <= ?
-            ORDER BY block_number ASC
-            """;
-
-        List<BlockEntry> result = new ArrayList<>();
-        try (PreparedStatement ps = c.prepareStatement(sql)) {
-            ps.setString(1, bchName);
-            ps.setInt(2, fromBlockNumberInclusive);
-            ps.setInt(3, toBlockNumberInclusive);
-            try (ResultSet rs = ps.executeQuery()) {
-                while (rs.next()) {
-                    result.add(mapRow(rs));
-                }
-            }
-        }
-        return result;
-    }
-
-    // -------------------- INTERNAL --------------------
-
-    private BlockEntry mapRow(ResultSet rs) throws SQLException {
-        BlockEntry e = new BlockEntry();
-
-        e.setLogin(rs.getString("login"));
-        e.setBchName(rs.getString("bch_name"));
-        e.setBlockNumber(rs.getInt("block_number"));
-
-        e.setMsgType(rs.getInt("msg_type"));
-        e.setMsgSubType(rs.getInt("msg_sub_type"));
-
-        e.setBlockBytes(rs.getBytes("block_bytes"));
-
-        String toLogin = rs.getString("to_login");
-        if (rs.wasNull()) toLogin = null;
-        e.setToLogin(toLogin);
-
-        String toBchName = rs.getString("to_bch_name");
-        if (rs.wasNull()) toBchName = null;
-        e.setToBchName(toBchName);
-
-        Integer toBlockNumber = (Integer) rs.getObject("to_block_number");
-        e.setToBlockNumber(toBlockNumber);
-
-        byte[] toHash = rs.getBytes("to_block_hash");
-        if (rs.wasNull()) toHash = null;
-        e.setToBlockHash(toHash);
-
-        e.setBlockHash(rs.getBytes("block_hash"));
-        e.setBlockSignature(rs.getBytes("block_signature"));
-
-        Integer editedBy = (Integer) rs.getObject("edited_by_block_number");
-        e.setEditedByBlockNumber(editedBy);
-
-        // NEW: line_code
-        Integer lineCode = (Integer) rs.getObject("line_code");
-        e.setLineCode(lineCode);
-
-        Integer prevLn = (Integer) rs.getObject("prev_line_number");
-        e.setPrevLineNumber(prevLn);
-
-        byte[] prevLh = rs.getBytes("prev_line_hash");
-        if (rs.wasNull()) prevLh = null;
-        e.setPrevLineHash(prevLh);
-
-        Integer thisLn = (Integer) rs.getObject("this_line_number");
-        e.setThisLineNumber(thisLn);
+    private 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,
+               arweave_publish_pending,arweave_published_at_ms,arweave_root_tx_id,
+               edited_by_block_number,line_code,prev_line_number,prev_line_hash,this_line_number
+        FROM blocks
+        """;}
 
+    private BlockEntry mapRow(ResultSet rs)throws SQLException{
+        BlockEntry e=new BlockEntry();
+        e.setLogin(rs.getString("login")); e.setBchName(rs.getString("bch_name")); e.setBlockNumber(rs.getInt("block_number"));
+        e.setMsgType(rs.getInt("msg_type")); e.setMsgSubType(rs.getInt("msg_sub_type")); e.setBlockBytes(rs.getBytes("block_bytes"));
+        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.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.setArweaveRootTxId(rs.getString("arweave_root_tx_id"));
+        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 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);}
 }

SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ChannelNameStateDAO.java

@@ -120,4 +120,15 @@ public final class ChannelNameStateDAO {
             insert(c, entry);
         }
     }
+    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";
+        try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setString(1, ownerBchName);
+            ps.setInt(2, rootBlockNumber);
+            try (ResultSet rs = ps.executeQuery()) {
+                return rs.next() ? rs.getString(1) : null;
+            }
+        }
+    }
+
 }

SHiNE-server/shine-server-db/src/main/java/shine/db/dao/ChannelReadStateDAO.java

@@ -0,0 +1,298 @@
+package shine.db.dao;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Server projection for per-user channel read/unread state.
+ *
+ * Important rules:
+ *  - rows are created only by a signed client SetChannelReadState;
+ *  - channel publications increment unread_count only for rows that already exist;
+ *  - read_count is monotonic and unread_count is reduced by the accepted read delta;
+ *  - unread_count is never part of the client signature and is server-owned.
+ */
+public final class ChannelReadStateDAO {
+    private static volatile ChannelReadStateDAO instance;
+
+    private ChannelReadStateDAO() {}
+
+    public static ChannelReadStateDAO getInstance() {
+        if (instance == null) {
+            synchronized (ChannelReadStateDAO.class) {
+                if (instance == null) instance = new ChannelReadStateDAO();
+            }
+        }
+        return instance;
+    }
+
+    public record ReadState(long readCount, long unreadCount, long readUpdatedAtMs,
+                            String clientKey, String readSignature) {}
+
+    public record UpsertResult(boolean applied, long readCount, long unreadCount) {}
+
+    public ReadState get(Connection c, String viewerLogin, String ownerBchName, String channelName) throws SQLException {
+        String sql = """
+            SELECT read_count, unread_count, read_updated_at_ms, client_key, read_signature
+            FROM channel_read_state
+            WHERE LOWER(viewer_login)=LOWER(?) AND owner_bch_name=? AND channel_name=?
+            LIMIT 1
+            """;
+        try (PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setString(1, viewerLogin);
+            ps.setString(2, ownerBchName);
+            ps.setString(3, channelName);
+            try (ResultSet rs = ps.executeQuery()) {
+                if (!rs.next()) return null;
+                return new ReadState(
+                        Math.max(0L, rs.getLong("read_count")),
+                        Math.max(0L, rs.getLong("unread_count")),
+                        rs.getLong("read_updated_at_ms"),
+                        rs.getString("client_key"),
+                        rs.getString("read_signature"));
+            }
+        }
+    }
+
+    public long getUnreadCount(Connection c, String viewerLogin, String ownerBchName, String channelName) throws SQLException {
+        ReadState state = get(c, viewerLogin, ownerBchName, channelName);
+        return state == null ? 0L : state.unreadCount();
+    }
+
+    public long sumUnreadCount(Connection c, String viewerLogin) throws SQLException {
+        String sql = """
+            SELECT COALESCE(SUM(crs.unread_count),0)
+            FROM channel_read_state crs
+            WHERE LOWER(crs.viewer_login)=LOWER(?)
+              AND EXISTS (
+                  SELECT 1
+                  FROM channel_names_state cns
+                  JOIN connections_state cs
+                    ON LOWER(cs.login)=LOWER(crs.viewer_login)
+                   AND cs.rel_type=30
+                   AND cs.to_bch_name=cns.owner_bch_name
+                   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
+                    AND cns.slug=crs.channel_name
+                    AND cns.channel_type_code=1
+              )
+            """;
+        try (PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setString(1, viewerLogin);
+            try (ResultSet rs = ps.executeQuery()) {
+                return rs.next() ? Math.max(0L, rs.getLong(1)) : 0L;
+            }
+        }
+    }
+
+    /**
+     * Validates that the requested public channel exists and that viewer currently follows it.
+     */
+    public boolean hasActiveSubscription(Connection c, String viewerLogin, String ownerBchName, String channelName,
+                                         int followRelType) throws SQLException {
+        String sql = """
+            SELECT 1
+            FROM channel_names_state cns
+            JOIN connections_state cs
+              ON LOWER(cs.login)=LOWER(?)
+             AND cs.rel_type=?
+             AND cs.to_bch_name=cns.owner_bch_name
+             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=?
+              AND cns.slug=?
+              AND cns.channel_type_code=1
+            LIMIT 1
+            """;
+        try (PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setString(1, viewerLogin);
+            ps.setInt(2, followRelType);
+            ps.setString(3, ownerBchName);
+            ps.setString(4, channelName);
+            try (ResultSet rs = ps.executeQuery()) {
+                return rs.next();
+            }
+        }
+    }
+
+    public String resolvePublicChannelNameByRoot(Connection c, String ownerBchName, int rootBlockNumber) throws SQLException {
+        String sql = """
+            SELECT slug
+            FROM channel_names_state
+            WHERE owner_bch_name=? AND channel_root_block_number=? AND channel_type_code=1
+            LIMIT 1
+            """;
+        try (PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setString(1, ownerBchName);
+            ps.setInt(2, rootBlockNumber);
+            try (ResultSet rs = ps.executeQuery()) {
+                return rs.next() ? rs.getString("slug") : null;
+            }
+        }
+    }
+
+
+    public Integer resolvePublicChannelRootByName(Connection c, String ownerBchName, String channelName) throws SQLException {
+        String sql = """
+            SELECT channel_root_block_number
+            FROM channel_names_state
+            WHERE owner_bch_name=? AND slug=? AND channel_type_code=1
+            LIMIT 1
+            """;
+        try (PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setString(1, ownerBchName);
+            ps.setString(2, channelName);
+            try (ResultSet rs = ps.executeQuery()) {
+                return rs.next() ? rs.getInt("channel_root_block_number") : null;
+            }
+        }
+    }
+
+    public String resolveOwnerLogin(Connection c, String ownerBchName, String channelName) throws SQLException {
+        String sql = """
+            SELECT owner_login
+            FROM channel_names_state
+            WHERE owner_bch_name=? AND slug=? AND channel_type_code=1
+            LIMIT 1
+            """;
+        try (PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setString(1, ownerBchName);
+            ps.setString(2, channelName);
+            try (ResultSet rs = ps.executeQuery()) {
+                return rs.next() ? rs.getString("owner_login") : null;
+            }
+        }
+    }
+
+    /**
+     * Inserts the first client baseline with unread=0, or advances an existing read watermark.
+     * Older timestamps and backwards read_count values are ignored.
+     */
+    public UpsertResult upsertSignedReadIfNewer(Connection c,
+                                                String viewerLogin,
+                                                String ownerLogin,
+                                                String ownerBchName,
+                                                String channelName,
+                                                long readCount,
+                                                long readUpdatedAtMs,
+                                                String clientKey,
+                                                String readSignature,
+                                                long nowMs) throws SQLException {
+        String sql = """
+            INSERT INTO channel_read_state (
+                viewer_login, owner_login, owner_bch_name, channel_name,
+                read_count, unread_count,
+                read_updated_at_ms, client_key, read_signature, updated_at_ms
+            ) VALUES (?, ?, ?, ?, ?, 0, ?, ?, ?, ?)
+            ON CONFLICT (viewer_login, owner_bch_name, channel_name)
+            DO UPDATE SET
+                owner_login = EXCLUDED.owner_login,
+                unread_count = GREATEST(
+                    0,
+                    channel_read_state.unread_count -
+                    GREATEST(0, EXCLUDED.read_count - channel_read_state.read_count)
+                ),
+                read_count = GREATEST(channel_read_state.read_count, EXCLUDED.read_count),
+                read_updated_at_ms = EXCLUDED.read_updated_at_ms,
+                client_key = EXCLUDED.client_key,
+                read_signature = EXCLUDED.read_signature,
+                updated_at_ms = EXCLUDED.updated_at_ms
+            WHERE channel_read_state.read_updated_at_ms < EXCLUDED.read_updated_at_ms
+              AND EXCLUDED.read_count >= channel_read_state.read_count
+            RETURNING read_count, unread_count
+            """;
+        try (PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setString(1, viewerLogin);
+            ps.setString(2, ownerLogin);
+            ps.setString(3, ownerBchName);
+            ps.setString(4, channelName);
+            ps.setLong(5, Math.max(0L, readCount));
+            ps.setLong(6, readUpdatedAtMs);
+            ps.setString(7, clientKey);
+            ps.setString(8, readSignature);
+            ps.setLong(9, nowMs);
+            try (ResultSet rs = ps.executeQuery()) {
+                if (rs.next()) {
+                    return new UpsertResult(true,
+                            Math.max(0L, rs.getLong("read_count")),
+                            Math.max(0L, rs.getLong("unread_count")));
+                }
+            }
+        }
+        ReadState current = get(c, viewerLogin, ownerBchName, channelName);
+        return new UpsertResult(false,
+                current == null ? 0L : current.readCount(),
+                current == null ? 0L : current.unreadCount());
+    }
+
+    /**
+     * Increments existing rows for current subscribers of one public channel.
+     * Missing channel_read_state rows are deliberately NOT created.
+     * Returns affected viewer logins for post-commit counter pushes.
+     */
+    public List<String> incrementUnreadForSubscribers(Connection c,
+                                                      String ownerBchName,
+                                                      String channelName,
+                                                      int followRelType,
+                                                      long nowMs) throws SQLException {
+        String sql = """
+            UPDATE channel_read_state crs
+            SET unread_count = crs.unread_count + 1,
+                updated_at_ms = ?
+            WHERE crs.owner_bch_name = ?
+              AND crs.channel_name = ?
+              AND LOWER(crs.viewer_login) <> LOWER(crs.owner_login)
+              AND EXISTS (
+                  SELECT 1
+                  FROM channel_names_state cns
+                  JOIN connections_state cs
+                    ON LOWER(cs.login)=LOWER(crs.viewer_login)
+                   AND cs.rel_type=?
+                   AND cs.to_bch_name=cns.owner_bch_name
+                   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
+                    AND cns.slug=crs.channel_name
+                    AND cns.channel_type_code=1
+              )
+            RETURNING viewer_login
+            """;
+        List<String> affected = new ArrayList<>();
+        try (PreparedStatement ps = c.prepareStatement(sql)) {
+            ps.setLong(1, nowMs);
+            ps.setString(2, ownerBchName);
+            ps.setString(3, channelName);
+            ps.setInt(4, followRelType);
+            try (ResultSet rs = ps.executeQuery()) {
+                while (rs.next()) affected.add(rs.getString("viewer_login"));
+            }
+        }
+        return affected;
+    }
+
+    /** Delete the projection row when a channel FOLLOW is explicitly removed. */
+    public boolean deleteForUnfollowTarget(Connection c, String viewerLogin, String ownerBchName,
+                                           int rootBlockNumber) throws SQLException {
+        String sql = """
+            DELETE FROM channel_read_state crs
+            USING channel_names_state cns
+            WHERE LOWER(crs.viewer_login)=LOWER(?)
+              AND crs.owner_bch_name=?
+              AND cns.owner_bch_name=crs.owner_bch_name
+              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.setInt(3, rootBlockNumber);
+            return ps.executeUpdate() > 0;
+        }
+    }
+}

SHiNE-server/shine-server-db/src/main/java/shine/db/dao/SolanaUserPdaCurrentDAO.java

@@ -8,6 +8,7 @@ import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.util.Base64;
 
 /**
  * Доступ к актуальной PostgreSQL-таблице пользователей, поддерживаемой sync-модулем.
@@ -60,6 +61,23 @@ public final class SolanaUserPdaCurrentDAO {
         }
     }
 
+    /** Resolve a current user by the 32-byte Ed25519 blockchain key used as ANS-104 owner. */
+    public SolanaUserPdaCurrentEntry getByBlockchainKey(byte[] owner32) throws SQLException {
+        if (owner32 == null || owner32.length != 32) return null;
+        String wanted = Base64.getEncoder().encodeToString(owner32);
+        String sql = """
+            SELECT login, blockchain_name, blockchain_key, paid_limit_bytes
+            FROM solana_user_pda_current
+            """;
+        try (Connection c = db.getConnection(); PreparedStatement ps = c.prepareStatement(sql); ResultSet rs = ps.executeQuery()) {
+            while (rs.next()) {
+                SolanaUserPdaCurrentEntry e = mapRow(rs);
+                if (wanted.equals(e.getBlockchainKey())) return e;
+            }
+        }
+        return null;
+    }
+
     private SolanaUserPdaCurrentEntry mapRow(ResultSet rs) throws SQLException {
         SolanaUserPdaCurrentEntry entry = new SolanaUserPdaCurrentEntry();
         entry.setLogin(rs.getString("login"));

SHiNE-server/shine-server-db/src/main/java/shine/db/entities/BlockEntry.java

@@ -37,6 +37,10 @@ public class BlockEntry {
 
     private byte[] blockHash;
     private byte[] blockSignature;
+    private byte[] dataItemId;
+    private boolean arweavePublishPending;
+    private Long arweavePublishedAtMs;
+    private String arweaveRootTxId;
 
     private Integer editedByBlockNumber;
 
@@ -85,6 +89,15 @@ public class BlockEntry {
     public byte[] getBlockSignature() { return blockSignature; }
     public void setBlockSignature(byte[] blockSignature) { this.blockSignature = blockSignature; }
 
+    public byte[] getDataItemId() { return dataItemId; }
+    public void setDataItemId(byte[] dataItemId) { this.dataItemId = dataItemId; }
+    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 String getArweaveRootTxId() { return arweaveRootTxId; }
+    public void setArweaveRootTxId(String arweaveRootTxId) { this.arweaveRootTxId = arweaveRootTxId; }
+
     public Integer getEditedByBlockNumber() { return editedByBlockNumber; }
     public void setEditedByBlockNumber(Integer editedByBlockNumber) { this.editedByBlockNumber = editedByBlockNumber; }
 

SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v21.sql

@@ -0,0 +1,25 @@
+-- Channel unread/read projection.
+-- The row is created only by a signed SetChannelReadState from the client.
+-- New channel publications only increment existing rows.
+
+CREATE TABLE IF NOT EXISTS channel_read_state (
+    viewer_login        TEXT NOT NULL REFERENCES solana_user_pda_current(login),
+    owner_login         TEXT NOT NULL,
+    owner_bch_name      TEXT NOT NULL,
+    channel_name        TEXT NOT NULL,
+    read_count          BIGINT NOT NULL DEFAULT 0 CHECK (read_count >= 0),
+    unread_count        BIGINT NOT NULL DEFAULT 0 CHECK (unread_count >= 0),
+    read_updated_at_ms  BIGINT NOT NULL,
+    client_key          TEXT NOT NULL,
+    read_signature      TEXT NOT NULL,
+    updated_at_ms       BIGINT NOT NULL,
+    PRIMARY KEY (viewer_login, owner_bch_name, channel_name)
+);
+
+CREATE INDEX IF NOT EXISTS idx_channel_read_state_viewer
+    ON channel_read_state(viewer_login);
+
+CREATE INDEX IF NOT EXISTS idx_channel_read_state_channel
+    ON channel_read_state(owner_bch_name, channel_name);
+
+UPDATE db_schema_version SET schema_version = 21 WHERE id = 1;

SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v22.sql

@@ -0,0 +1,56 @@
+CREATE TABLE IF NOT EXISTS archive_chain_cursor (
+    blockchain_name                    TEXT PRIMARY KEY,
+    last_archived_source_block_number  BIGINT NOT NULL,
+    last_archived_source_block_hash    BYTEA NOT NULL,
+    last_archive_big_block_number      BIGINT NOT NULL,
+    last_archive_big_block_hash        BYTEA NOT NULL,
+    last_chunk_offset                  BIGINT NOT NULL,
+    last_chunk_size                    BIGINT NOT NULL,
+    updated_at_ms                      BIGINT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS archive_publish_job (
+    id                       BIGSERIAL PRIMARY KEY,
+    big_block_number         BIGINT NOT NULL,
+    status                   TEXT NOT NULL,
+    created_at_ms            BIGINT NOT NULL,
+    local_archive_path       TEXT,
+    archive_hash             BYTEA,
+    arweave_tx_id            BYTEA,
+    arweave_confirmations    INTEGER,
+    solana_signature         TEXT,
+    error_text               TEXT,
+    updated_at_ms            BIGINT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_archive_publish_job_status
+    ON archive_publish_job(status);
+CREATE INDEX IF NOT EXISTS idx_archive_publish_job_big_block_number
+    ON archive_publish_job(big_block_number);
+
+CREATE TABLE IF NOT EXISTS archive_publish_job_chain (
+    job_id                              BIGINT NOT NULL REFERENCES archive_publish_job(id) ON DELETE CASCADE,
+    blockchain_name                    TEXT NOT NULL,
+    from_source_block_number           BIGINT NOT NULL,
+    to_source_block_number             BIGINT NOT NULL,
+    previous_source_block_hash         BYTEA NOT NULL,
+    last_source_block_hash             BYTEA NOT NULL,
+    previous_archive_big_block_number  BIGINT,
+    previous_archive_big_block_hash    BYTEA,
+    previous_chunk_offset              BIGINT,
+    previous_chunk_size                BIGINT,
+    new_chunk_offset                   BIGINT,
+    new_chunk_size                     BIGINT,
+    PRIMARY KEY (job_id, blockchain_name)
+);
+
+ALTER TABLE solana_user_pda_current
+    ADD COLUMN IF NOT EXISTS archive_head_tx_id TEXT NOT NULL DEFAULT '';
+ALTER TABLE solana_user_pda_current
+    ADD COLUMN IF NOT EXISTS archive_head_hash TEXT NOT NULL DEFAULT '';
+ALTER TABLE solana_user_pda_history
+    ADD COLUMN IF NOT EXISTS archive_head_tx_id TEXT NOT NULL DEFAULT '';
+ALTER TABLE solana_user_pda_history
+    ADD COLUMN IF NOT EXISTS archive_head_hash TEXT NOT NULL DEFAULT '';
+
+UPDATE db_schema_version SET schema_version = 22, updated_at_ms = CAST(EXTRACT(EPOCH FROM clock_timestamp())*1000 AS BIGINT) WHERE id = 1;

SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v23.sql

@@ -0,0 +1,32 @@
+-- v23: trusted SHINE-ARCHIVE import state + last chunk location index.
+-- Solana archive head itself is already copied by the normal Solana users sync (v22).
+
+ALTER TABLE solana_user_pda_current
+    ADD COLUMN IF NOT EXISTS archive_imported BOOLEAN NOT NULL DEFAULT FALSE;
+
+ALTER TABLE solana_user_pda_current
+    ADD COLUMN IF NOT EXISTS archive_last_imported_tx_id TEXT NOT NULL DEFAULT '';
+
+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 <> '';
+
+CREATE TABLE IF NOT EXISTS archive_blockchain_location (
+    blockchain_name           TEXT PRIMARY KEY,
+    publisher_login           TEXT NOT NULL,
+    arweave_tx_id             TEXT NOT NULL,
+    archive_hash              BYTEA NOT NULL,
+    big_block_number          BIGINT NOT NULL,
+    chunk_offset              BIGINT NOT NULL,
+    chunk_size                BIGINT NOT NULL,
+    source_last_block_number  BIGINT NOT NULL,
+    updated_at_ms             BIGINT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_archive_blockchain_location_publisher
+    ON archive_blockchain_location(publisher_login);
+
+UPDATE db_schema_version
+SET schema_version = 23,
+    updated_at_ms = CAST(EXTRACT(EPOCH FROM clock_timestamp())*1000 AS BIGINT)
+WHERE id = 1;

SHiNE-server/shine-server-db/src/main/resources/postgres/migration_v24.sql

@@ -0,0 +1,56 @@
+-- Frame v1 intentionally has no backward compatibility with the old signed block format.
+-- Refuse to migrate a populated blockchain database: test/dev data must be reset first.
+DO $$
+BEGIN
+    IF EXISTS (SELECT 1 FROM blocks LIMIT 1)
+       OR EXISTS (SELECT 1 FROM blockchain_state WHERE last_block_number >= 0 LIMIT 1) THEN
+        RAISE EXCEPTION 'migration_v24 requires an empty blockchain database; reset test/dev blockchain data before upgrading';
+    END IF;
+END $$;
+
+-- Старый SHINE-ARCHIVE v1 больше не используется.
+DROP TABLE IF EXISTS archive_publish_job_chain CASCADE;
+DROP TABLE IF EXISTS archive_publish_job CASCADE;
+DROP TABLE IF EXISTS archive_chain_cursor CASCADE;
+DROP TABLE IF EXISTS archive_blockchain_location CASCADE;
+
+-- SHiNE Frame v1 / ANS-104 DataItem storage. No legacy .bch files are required.
+ALTER TABLE blocks
+    ADD COLUMN IF NOT EXISTS data_item_id BYTEA;
+ALTER TABLE blocks
+    ADD COLUMN IF NOT EXISTS arweave_publish_pending BOOLEAN NOT NULL DEFAULT FALSE;
+ALTER TABLE blocks
+    ADD COLUMN IF NOT EXISTS arweave_published_at_ms BIGINT;
+ALTER TABLE blocks
+    ADD COLUMN IF NOT EXISTS arweave_root_tx_id TEXT;
+
+CREATE UNIQUE INDEX IF NOT EXISTS uq_blocks_data_item_id
+    ON blocks(data_item_id)
+    WHERE data_item_id IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_blocks_arweave_publish_pending
+    ON blocks(block_number)
+    WHERE arweave_publish_pending = TRUE;
+
+CREATE TABLE IF NOT EXISTS arweave_block_sync_state (
+    id                 SMALLINT PRIMARY KEY CHECK (id = 1),
+    last_block_height  BIGINT NOT NULL DEFAULT 0,
+    updated_at_ms      BIGINT NOT NULL DEFAULT 0
+);
+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
+);
+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';
+
+UPDATE db_schema_version SET schema_version=24, updated_at_ms=CAST(EXTRACT(EPOCH FROM clock_timestamp())*1000 AS BIGINT) WHERE id=1;

SHiNE-server/shine-server-db/src/main/resources/postgres/schema_v1.sql

@@ -22,7 +22,7 @@ CREATE TABLE IF NOT EXISTS db_schema_version (
 );
 
 INSERT INTO db_schema_version (id, schema_version, updated_at_ms)
-    VALUES (1, 20, CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT))
+    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;
@@ -291,12 +291,6 @@ AFTER TRUNCATE ON solana_user_pda_current
 FOR EACH STATEMENT
 EXECUTE FUNCTION trg_refresh_user_access_servers_from_user_pda_truncate();
 
-DROP TRIGGER IF EXISTS trg_user_stats_state_ai ON solana_user_pda_current;
-CREATE TRIGGER trg_user_stats_state_ai
-AFTER INSERT ON solana_user_pda_current
-FOR EACH ROW
-EXECUTE FUNCTION shine_user_stats_state_ai();
-
 CREATE TABLE IF NOT EXISTS solana_user_pda_history (
     id                       BIGSERIAL PRIMARY KEY,
     tx_signature             TEXT NOT NULL,
@@ -425,6 +419,26 @@ CREATE INDEX IF NOT EXISTS idx_user_settings_login
 CREATE INDEX IF NOT EXISTS idx_user_settings_type_key
     ON user_settings(setting_type, setting_key);
 
+CREATE TABLE IF NOT EXISTS channel_read_state (
+    viewer_login        TEXT NOT NULL REFERENCES solana_user_pda_current(login),
+    owner_login         TEXT NOT NULL,
+    owner_bch_name      TEXT NOT NULL,
+    channel_name        TEXT NOT NULL,
+    read_count          BIGINT NOT NULL DEFAULT 0 CHECK (read_count >= 0),
+    unread_count        BIGINT NOT NULL DEFAULT 0 CHECK (unread_count >= 0),
+    read_updated_at_ms  BIGINT NOT NULL,
+    client_key          TEXT NOT NULL,
+    read_signature      TEXT NOT NULL,
+    updated_at_ms       BIGINT NOT NULL,
+    PRIMARY KEY (viewer_login, owner_bch_name, channel_name)
+);
+
+CREATE INDEX IF NOT EXISTS idx_channel_read_state_viewer
+    ON channel_read_state(viewer_login);
+
+CREATE INDEX IF NOT EXISTS idx_channel_read_state_channel
+    ON channel_read_state(owner_bch_name, channel_name);
+
 CREATE TABLE IF NOT EXISTS ip_geo_cache (
     ip             TEXT PRIMARY KEY,
     geo            TEXT,
@@ -483,6 +497,10 @@ CREATE TABLE IF NOT EXISTS blocks (
     to_block_hash            BYTEA,
     block_hash               BYTEA NOT NULL,
     block_signature          BYTEA NOT NULL,
+    data_item_id             BYTEA NOT NULL,
+    arweave_publish_pending  BOOLEAN NOT NULL DEFAULT FALSE,
+    arweave_published_at_ms  BIGINT,
+    arweave_root_tx_id       TEXT,
     edited_by_block_number   INTEGER CHECK (edited_by_block_number IS NULL OR edited_by_block_number >= 0),
     line_code                INTEGER CHECK (line_code IS NULL OR line_code >= 0),
     prev_line_number         INTEGER CHECK (prev_line_number IS NULL OR prev_line_number >= 0),
@@ -494,12 +512,41 @@ CREATE TABLE IF NOT EXISTS blocks (
 CREATE INDEX IF NOT EXISTS idx_blocks_by_chain_number
     ON blocks (bch_name, block_number);
 
+CREATE UNIQUE INDEX IF NOT EXISTS uq_blocks_data_item_id
+    ON blocks(data_item_id);
+
+CREATE INDEX IF NOT EXISTS idx_blocks_arweave_publish_pending
+    ON blocks(block_number)
+    WHERE arweave_publish_pending = TRUE;
+
 CREATE INDEX IF NOT EXISTS idx_blocks_to_target
     ON blocks (to_login, to_bch_name, to_block_number);
 
 CREATE INDEX IF NOT EXISTS idx_blocks_by_line
     ON blocks (bch_name, line_code, this_line_number);
 
+CREATE TABLE IF NOT EXISTS arweave_block_sync_state (
+    id                 SMALLINT PRIMARY KEY CHECK (id = 1),
+    last_block_height  BIGINT NOT NULL DEFAULT 0,
+    updated_at_ms      BIGINT NOT NULL DEFAULT 0
+);
+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
+);
+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 TABLE IF NOT EXISTS connections_state (
     login           TEXT NOT NULL REFERENCES solana_user_pda_current(normalized_login),
     rel_type        INTEGER NOT NULL,
@@ -1640,6 +1687,12 @@ AFTER INSERT ON blocks
 FOR EACH ROW
 EXECUTE FUNCTION shine_blocks_edit_apply_ai();
 
+DROP TRIGGER IF EXISTS trg_user_stats_state_ai ON solana_user_pda_current;
+CREATE TRIGGER trg_user_stats_state_ai
+AFTER INSERT ON solana_user_pda_current
+FOR EACH ROW
+EXECUTE FUNCTION shine_user_stats_state_ai();
+
 DROP TRIGGER IF EXISTS trg_channel_names_state_stats_ai ON channel_names_state;
 CREATE TRIGGER trg_channel_names_state_stats_ai
 AFTER INSERT ON channel_names_state
@@ -2008,9 +2061,27 @@ CREATE TABLE IF NOT EXISTS user_notification_seen_state (
     PRIMARY KEY (owner_login, category)
 );
 
+ALTER TABLE solana_user_pda_current
+    ADD COLUMN IF NOT EXISTS archive_head_tx_id TEXT NOT NULL DEFAULT '';
+ALTER TABLE solana_user_pda_current
+    ADD COLUMN IF NOT EXISTS archive_head_hash TEXT NOT NULL DEFAULT '';
+ALTER TABLE solana_user_pda_history
+    ADD COLUMN IF NOT EXISTS archive_head_tx_id TEXT NOT NULL DEFAULT '';
+ALTER TABLE solana_user_pda_history
+    ADD COLUMN IF NOT EXISTS archive_head_hash TEXT NOT NULL DEFAULT '';
+
+
+ALTER TABLE solana_user_pda_current
+    ADD COLUMN IF NOT EXISTS archive_imported BOOLEAN NOT NULL DEFAULT FALSE;
+ALTER TABLE solana_user_pda_current
+    ADD COLUMN IF NOT EXISTS archive_last_imported_tx_id TEXT NOT NULL DEFAULT '';
+
+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,20,CAST(EXTRACT(EPOCH FROM clock_timestamp())*1000 AS BIGINT))
+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;
 
 COMMIT;
-

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/JsonHandlerRegistry.java

@@ -46,11 +46,7 @@ import server.logic.ws_protocol.JSON.handlers.blockchain.entyties.Net_AddBlock_R
 import server.logic.ws_protocol.JSON.handlers.blockchain.entyties.Net_GetBlockchainBlock_Request;
 
 import server.logic.ws_protocol.JSON.handlers.tempToTest.Net_GetUser_Handler;
-import server.logic.ws_protocol.JSON.handlers.tempToTest.Net_TestGetFreeAvatarQuota_Handler;
-import server.logic.ws_protocol.JSON.handlers.tempToTest.Net_TestUploadFreeAvatar_Handler;
 import server.logic.ws_protocol.JSON.handlers.tempToTest.entyties.Net_GetUser_Request;
-import server.logic.ws_protocol.JSON.handlers.tempToTest.entyties.Net_TestGetFreeAvatarQuota_Request;
-import server.logic.ws_protocol.JSON.handlers.tempToTest.entyties.Net_TestUploadFreeAvatar_Request;
 
 // --- NEW: SearchUsers ---
 import server.logic.ws_protocol.JSON.handlers.tempToTest.Net_SearchUsers_Handler;
@@ -75,20 +71,24 @@ import server.logic.ws_protocol.JSON.handlers.connections.entyties.Net_GetFriend
 import server.logic.ws_protocol.JSON.handlers.channels.ChannelNamesStateBootstrapper;
 import server.logic.ws_protocol.JSON.handlers.channels.Net_GetChannelMessages_Handler;
 import server.logic.ws_protocol.JSON.handlers.channels.Net_GetMessageThread_Handler;
+import server.logic.ws_protocol.JSON.handlers.channels.Net_GetMessageLikes_Handler;
 import server.logic.ws_protocol.JSON.handlers.channels.Net_GetPersonalDiary_Handler;
 import server.logic.ws_protocol.JSON.handlers.channels.Net_GetGroupDialog_Handler;
 import server.logic.ws_protocol.JSON.handlers.channels.Net_GetChannelsCounters_Handler;
 import server.logic.ws_protocol.JSON.handlers.channels.Net_ListGroupChats200_Handler;
 import server.logic.ws_protocol.JSON.handlers.channels.Net_ListSubscriptionsFeed_Handler;
 import server.logic.ws_protocol.JSON.handlers.channels.Net_GetUserCounters_Handler;
+import server.logic.ws_protocol.JSON.handlers.channels.Net_SetChannelReadState_Handler;
 import server.logic.ws_protocol.JSON.handlers.channels.entyties.Net_GetChannelsCounters_Request;
 import server.logic.ws_protocol.JSON.handlers.channels.entyties.Net_GetChannelMessages_Request;
 import server.logic.ws_protocol.JSON.handlers.channels.entyties.Net_GetGroupDialog_Request;
 import server.logic.ws_protocol.JSON.handlers.channels.entyties.Net_GetMessageThread_Request;
+import server.logic.ws_protocol.JSON.handlers.channels.entyties.Net_GetMessageLikes_Request;
 import server.logic.ws_protocol.JSON.handlers.channels.entyties.Net_GetPersonalDiary_Request;
 import server.logic.ws_protocol.JSON.handlers.channels.entyties.Net_ListGroupChats200_Request;
 import server.logic.ws_protocol.JSON.handlers.channels.entyties.Net_ListSubscriptionsFeed_Request;
 import server.logic.ws_protocol.JSON.handlers.channels.entyties.Net_GetUserCounters_Request;
+import server.logic.ws_protocol.JSON.handlers.channels.entyties.Net_SetChannelReadState_Request;
 import server.logic.ws_protocol.JSON.handlers.connections.Net_GetUserConnectionsGraph_Handler;
 import server.logic.ws_protocol.JSON.handlers.profile.Net_ListUserProfileRelations_Handler;
 import server.logic.ws_protocol.JSON.handlers.profile.Net_ListUserProfileChannels_Handler;
@@ -161,8 +161,6 @@ public final class JsonHandlerRegistry {
     private static final Map<String, JsonMessageHandler> HANDLERS = Map.ofEntries(
             Map.entry("GetUser",            new Net_GetUser_Handler()),
             Map.entry("SearchUsers",        new Net_SearchUsers_Handler()),
-            Map.entry("TestGetFreeAvatarQuota", new Net_TestGetFreeAvatarQuota_Handler()),
-            Map.entry("TestUploadFreeAvatar", new Net_TestUploadFreeAvatar_Handler()),
 
             // --- auth ---
             Map.entry("ResolveLoginForAuth", new Net_ResolveLoginForAuth_Handler()),
@@ -210,10 +208,12 @@ public final class JsonHandlerRegistry {
             Map.entry("GetChannelMessages", new Net_GetChannelMessages_Handler()),
             Map.entry("GetPersonalDiary", new Net_GetPersonalDiary_Handler()),
             Map.entry("GetMessageThread", new Net_GetMessageThread_Handler()),
+            Map.entry("GetMessageLikes", new Net_GetMessageLikes_Handler()),
             Map.entry("GetGroupDialog", new Net_GetGroupDialog_Handler()),
             Map.entry("ListGroupChats200", new Net_ListGroupChats200_Handler()),
             Map.entry("GetChannelsCounters", new Net_GetChannelsCounters_Handler()),
             Map.entry("GetUserCounters", new Net_GetUserCounters_Handler()),
+            Map.entry("SetChannelReadState", new Net_SetChannelReadState_Handler()),
             Map.entry("ListContacts", new Net_ListContacts_Handler()),
             Map.entry("GetUserConnectionsGraph", new Net_GetUserConnectionsGraph_Handler()),
             Map.entry("ListUserProfileRelations", new Net_ListUserProfileRelations_Handler()),
@@ -253,8 +253,6 @@ public final class JsonHandlerRegistry {
     private static final Map<String, Class<? extends Net_Request>> REQUEST_TYPES = Map.ofEntries(
             Map.entry("GetUser",            Net_GetUser_Request.class),
             Map.entry("SearchUsers",        Net_SearchUsers_Request.class),
-            Map.entry("TestGetFreeAvatarQuota", Net_TestGetFreeAvatarQuota_Request.class),
-            Map.entry("TestUploadFreeAvatar", Net_TestUploadFreeAvatar_Request.class),
 
             // --- auth ---
             Map.entry("ResolveLoginForAuth", Net_ResolveLoginForAuth_Request.class),
@@ -302,10 +300,12 @@ public final class JsonHandlerRegistry {
             Map.entry("GetChannelMessages", Net_GetChannelMessages_Request.class),
             Map.entry("GetPersonalDiary", Net_GetPersonalDiary_Request.class),
             Map.entry("GetMessageThread", Net_GetMessageThread_Request.class),
+            Map.entry("GetMessageLikes", Net_GetMessageLikes_Request.class),
             Map.entry("GetGroupDialog", Net_GetGroupDialog_Request.class),
             Map.entry("ListGroupChats200", Net_ListGroupChats200_Request.class),
             Map.entry("GetChannelsCounters", Net_GetChannelsCounters_Request.class),
             Map.entry("GetUserCounters", Net_GetUserCounters_Request.class),
+            Map.entry("SetChannelReadState", Net_SetChannelReadState_Request.class),
             Map.entry("ListContacts", Net_ListContacts_Request.class),
             Map.entry("GetUserConnectionsGraph", Net_GetUserConnectionsGraph_Request.class),
             Map.entry("ListUserProfileRelations", Net_ListUserProfileRelations_Request.class),

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/SolanaUserPdaImportService.java

@@ -28,6 +28,7 @@ public final class SolanaUserPdaImportService {
     private static final HttpClient HTTP = HttpClient.newHttpClient();
     private static final String MAGIC = "SHiNE";
     private static final int MAX_EFFECTIVE_ACCESS_SERVERS = 1;
+    private static final int ARCHIVE_HEAD_PAYLOAD_BYTES = 64;
 
     private SolanaUserPdaImportService() {}
 
@@ -266,6 +267,8 @@ public final class SolanaUserPdaImportService {
                 }
             } else if (blockType == 70) {
                 c += 1;
+            } else if (blockType == 100) {
+                c += ARCHIVE_HEAD_PAYLOAD_BYTES;
             } else {
                 return null;
             }
@@ -374,6 +377,8 @@ public final class SolanaUserPdaImportService {
                 }
             } else if (blockType == 70) {
                 c += 1;
+            } else if (blockType == 100) {
+                c += ARCHIVE_HEAD_PAYLOAD_BYTES;
             } else {
                 return null;
             }

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_AddBlock_Handler.java

@@ -26,6 +26,7 @@ import server.logic.ws_protocol.JSON.handlers.blockchain.entyties.Net_AddBlock_R
 import server.logic.ws_protocol.JSON.handlers.blockchain.entyties.Net_AddBlock_Response;
 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 shine.db.channels.ChannelNameRules;
@@ -42,6 +43,7 @@ import shine.db.entities.UserParamEntry;
 import utils.blockchain.BlockchainNameUtil;
 
 import java.util.Arrays;
+import java.util.List;
 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
@@ -100,7 +102,9 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
                     blockchainName,
                     req.getBlockNumber(),        // старое поле, пока оставляем
                     req.getPrevBlockHash(),      // старое поле, пока оставляем
-                    req.getBlockBytesB64()
+                    req.getBlockBytesB64(),
+                    true,
+                    true
             );
 
             // ✅ УСПЕХ: как раньше
@@ -160,6 +164,8 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
             case "limit_exceeded" -> "Превышен лимит размера блокчейна";
             case "limit_check_failed" -> "Ошибка проверки лимита размера";
             case "bad_block_format" -> "Некорректный формат блока";
+            case "bad_app_tag" -> "Некорректный тестовый тег ANS-104";
+            case "bad_channel_tag" -> "Некорректный тег канала ANS-104";
             case "bad_block_body" -> "Некорректное тело блока";
             case "bad_channel_name" -> "Некорректное название канала";
             case "bad_block_number" -> "Некорректный номер блока";
@@ -186,7 +192,9 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
             String blockchainName,
             int globalNumberFromReq,
             String prevGlobalHashHexFromReq,
-            String blockBytesB64
+            String blockBytesB64,
+            boolean replicateAfterWrite,
+            boolean publishToArweave
     ) {
         if (blockchainName == null || blockchainName.isBlank()) {
             log.warn("AddBlock: пустой blockchainName (reqGlobalNumber={})", globalNumberFromReq);
@@ -268,6 +276,10 @@ 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")) {
+            return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_app_tag", serverLastNum, serverLastHashHex);
+        }
+
         // body.check()
         try {
             block.body.check();
@@ -397,6 +409,22 @@ 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=<slug>.
+        try {
+            String expectedChannelSlug = expectedChannelSlug(blockchainName, block, channelNameStateEntry);
+            String actualChannelSlug = block.getDataItem().tagValue("c");
+            if (expectedChannelSlug != null) {
+                if (!expectedChannelSlug.equals(actualChannelSlug)) {
+                    return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_channel_tag", serverLastNum, serverLastHashHex);
+                }
+            } else if (actualChannelSlug != null) {
+                return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_channel_tag", serverLastNum, serverLastHashHex);
+            }
+        } catch (Exception e) {
+            log.warn("AddBlock: cannot validate channel tag blockchainName={} block={}", blockchainName, block.blockNumber, e);
+            return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_channel_tag", serverLastNum, serverLastHashHex);
+        }
+
         if ((block.type & 0xFFFF) == 1
                 && (block.subType & 0xFFFF) == (MsgSubType.TEXT_EDIT_POST & 0xFFFF)) {
             try {
@@ -454,7 +482,7 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
             return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "bad_blockchain_key_len", serverLastNum, serverLastHashHex);
         }
 
-        // 6) подпись по hash32(preimage)
+        // 6) ANS-104 Ed25519 подпись и owner
         boolean sigOk;
         try {
             sigOk = BchCryptoVerifier.verifyBlock(block, pubKey32);
@@ -512,7 +540,7 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
             }
         }
 
-        // 8) сформировать запись и записать (DB + state + файл)
+        // 8) сформировать запись и атомарно записать в PostgreSQL вместе с новым state
         try {
             BlockEntry be = new BlockEntry();
             be.setLogin(login);
@@ -525,6 +553,8 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
             be.setBlockBytes(block.toBytes());
             be.setBlockHash(block.getHash32());
             be.setBlockSignature(block.getSignature64());
+            be.setDataItemId(block.getDataItemId32());
+            be.setArweavePublishPending(publishToArweave);
 
             // line columns (optional)
             be.setLineCode(lineCode);
@@ -586,9 +616,13 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
             }
 
             UserNotificationEntry notificationEntry = buildNotificationEntry(block, be);
-            dbWriter.appendBlockAndState(
+            List<String> counterChangedLogins = dbWriter.appendBlockAndState(
                     blockchainName, block, st, be, upsertedParam, channelNameStateEntry, channelMetaUpdateEntry, notificationEntry);
 
+            for (String changedLogin : counterChangedLogins) {
+                UserCountersSupport.pushChanged(changedLogin);
+            }
+
             if (chat200CreateSeed != null) {
                 upsertChat200StateFromCreate(chat200CreateSeed);
             }
@@ -607,15 +641,80 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
         log.info("✅ AddBlock ok: login={}, blockchainName={}, blockNumber={}, newHash={}",
                 login, blockchainName, block.blockNumber, newHashHex);
 
-        addBlockSyncService.replicateAsync(blockchainName, block.blockNumber);
+        if (replicateAfterWrite) {
+            addBlockSyncService.replicateAsync(blockchainName, block.blockNumber);
+        }
 
         return new AddBlockResult(WireCodes.Status.OK, null, block.blockNumber, newHashHex);
     }
 
+    /**
+     * Архивный импорт использует ту же проверку и запись, что обычный AddBlock,
+     * но не запускает повторную межсерверную репликацию уже импортированного блока.
+     */
+    public ArweaveImportResult addBlockFromArweave(String blockchainName, byte[] rawBlockBytes) {
+        if (BlockchainResyncGuard.isBlockedForExternalAddBlock(blockchainName)) {
+            return new ArweaveImportResult(false, "chain_resync_in_progress", -1, "");
+        }
+        if (rawBlockBytes == null || rawBlockBytes.length == 0) {
+            return new ArweaveImportResult(false, "empty_block", -1, "");
+        }
+        try {
+            BchBlockEntry probe = new BchBlockEntry(rawBlockBytes);
+            if (blocksDAO.existsByDataItemId(probe.getDataItemId32())) {
+                return new ArweaveImportResult(true, "already_present", probe.blockNumber, toHex(probe.getHash32()));
+            }
+        } catch (Exception ignored) {
+            // Parsed again below to return the canonical bad_block_format result.
+        }
+        final BchBlockEntry parsed;
+        try {
+            parsed = new BchBlockEntry(rawBlockBytes);
+        } catch (Exception e) {
+            return new ArweaveImportResult(false, "bad_block_format", -1, "");
+        }
+        ReentrantLock lock = BlockchainLocks.lockFor(blockchainName);
+        lock.lock();
+        try {
+            AddBlockResult r = addBlock(
+                    blockchainName,
+                    parsed.blockNumber,
+                    toHex(parsed.prevHash32),
+                    Base64Ws.encode(rawBlockBytes),
+                    false,
+                    false
+            );
+            return new ArweaveImportResult(r.isOk(), r.reasonCode, r.serverLastBlockNumber, r.serverLastBlockHashHex);
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    public record ArweaveImportResult(boolean ok, String reasonCode, int serverLastBlockNumber, String serverLastBlockHashHex) {}
+
     /* ===================================================================== */
     /* ====================== Helpers ====================================== */
     /* ===================================================================== */
 
+    private String expectedChannelSlug(String blockchainName, BchBlockEntry block, ChannelNameStateEntry justCreated) throws Exception {
+        if (block.body instanceof CreateChannelBody) {
+            return justCreated == null ? null : justCreated.getSlug();
+        }
+        int type = block.type & 0xffff;
+        int sub = block.subType & 0xffff;
+        boolean channelBlock = type == 1 && (
+                sub == (MsgSubType.TEXT_POST & 0xffff)
+                || sub == (MsgSubType.TEXT_REPOST & 0xffff)
+                || sub == (MsgSubType.TEXT_CHANNEL_META & 0xffff)
+                || sub == (MsgSubType.TEXT_ENTRYPOINT & 0xffff)
+                || sub == (MsgSubType.TEXT_EXERCISE & 0xffff)
+                || sub == (MsgSubType.TEXT_SERVICE & 0xffff)
+                || sub == (MsgSubType.TEXT_COURSE & 0xffff)
+                || sub == (MsgSubType.TEXT_EDIT_POST & 0xffff));
+        if (!channelBlock || !(block.body instanceof BodyHasLine line) || line.lineCode() <= 0) return null;
+        return channelNameStateDAO.getSlugByOwnerAndRoot(blockchainName, line.lineCode());
+    }
+
     private String validateConnectionVotingRights(String actorLogin, int subType, String targetLogin) {
         if (subType != (MsgSubType.CONNECTION_OFFICIAL_ACCOUNT_CONFIRMED & 0xFFFF)
                 && subType != (MsgSubType.CONNECTION_SHINE_CONFIRMED & 0xFFFF)) return null;

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/blockchain/Net_AddBlock_Handler_utils/BlockchainWriter.java

@@ -4,6 +4,8 @@ import blockchain.BchBlockEntry;
 import shine.db.dao.BlockchainStateDAO;
 import shine.db.dao.BlocksDAO;
 import shine.db.dao.ChannelNameStateDAO;
+import shine.db.dao.ChannelReadStateDAO;
+import shine.db.MsgSubType;
 import shine.db.dao.UserParamsDAO;
 import shine.db.dao.UserNotificationsStateDAO;
 import shine.db.entities.BlockchainStateEntry;
@@ -11,40 +13,24 @@ import shine.db.entities.BlockEntry;
 import shine.db.entities.ChannelNameStateEntry;
 import shine.db.entities.UserParamEntry;
 import shine.db.entities.UserNotificationEntry;
-import utils.files.FileStoreUtil;
 
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
 import java.sql.Connection;
 import java.sql.SQLException;
-import java.util.HexFormat;
+import java.util.ArrayList;
+import java.util.List;
 
-/**
- * BlockchainWriter — запись блока в БД и формирование файловой версии цепочки.
- *
- * Текущая схема:
- *  1) собираем <blockchainName>.tmp_bch как готовый кандидат на замену основного файла;
- *  2) пишем маленький sidecar <blockchainName>.write_check с blockNumber/blockHash;
- *  3) создаём пустой marker <blockchainName>.write_pending;
- *  4) выполняем одну SQL-транзакцию;
- *  5) после commit атомарно заменяем основной .bch из tmp;
- *  6) убираем временные файлы.
- *
- * Recovery на старте смотрит на marker/check/tmp и добивает незавершённую запись:
- *  - если marker отсутствует, а tmp/check остались, это мусор;
- *  - если marker есть, recovery проверяет БД и либо завершает swap, либо очищает мусор.
+/** Stores the complete ANS-104 DataItem and all derived SHiNE state atomically in PostgreSQL.
+ * Local .bch/tmp/marker files are intentionally not used.
  */
 public final class BlockchainWriter {
 
-    private static final HexFormat HEX = HexFormat.of();
 
     private final BlocksDAO blocksDAO;
     private final BlockchainStateDAO stateDAO;
     private final ChannelNameStateDAO channelNameStateDAO;
     private final UserParamsDAO userParamsDAO;
     private final UserNotificationsStateDAO userNotificationsStateDAO;
-    private final FileStoreUtil fs = FileStoreUtil.getInstance();
+    private final ChannelReadStateDAO channelReadStateDAO = ChannelReadStateDAO.getInstance();
 
     public BlockchainWriter(BlocksDAO blocksDAO,
                             BlockchainStateDAO stateDAO,
@@ -58,7 +44,11 @@ public final class BlockchainWriter {
         this.userNotificationsStateDAO = userNotificationsStateDAO;
     }
 
-    public void appendBlockAndState(String blockchainName,
+    /**
+     * Stores the complete ANS-104 DataItem and all SQL projections in one DB transaction.
+     * There is intentionally no .bch/tmp/marker file layer anymore.
+     */
+    public List<String> appendBlockAndState(String blockchainName,
                                     BchBlockEntry block,
                                     BlockchainStateEntry st,
                                     BlockEntry be,
@@ -68,121 +58,64 @@ public final class BlockchainWriter {
                                     UserNotificationEntry notificationEntry) throws SQLException {
 
         long nowMs = System.currentTimeMillis();
-        byte[] blockBytes = block.toBytes();
-        byte[] candidateBytes = buildCandidateBlockchainBytes(blockchainName, blockBytes);
-        String blockHashHex = HEX.formatHex(block.getHash32());
-
-        prepareWriteArtifacts(blockchainName, block.blockNumber, blockHashHex, candidateBytes);
-
-        boolean committed = false;
+        byte[] rawDataItem = block.toBytes();
+        List<String> counterChangedLogins = new ArrayList<>();
         try (Connection c = shine.db.DbController.getInstance().getConnection()) {
             c.setAutoCommit(false);
             try {
-                // 1) insert block
                 blocksDAO.insert(c, be);
 
-                // 2) update state
                 st.setLastBlockNumber(block.blockNumber);
                 st.setLastBlockHash(block.getHash32());
-                st.setFileSizeBytes(st.getFileSizeBytes() + blockBytes.length);
+                st.setFileSizeBytes(st.getFileSizeBytes() + rawDataItem.length);
                 st.setUpdatedAtMs(nowMs);
-
                 stateDAO.upsert(c, st);
 
-                // 2.1) Если блок — USER_PARAM, синхронизируем снимок в users_params в той же транзакции.
-                if (userParamEntry != null) {
-                    userParamsDAO.upsertIfNewer(c, userParamEntry);
+                if (userParamEntry != null) userParamsDAO.upsertIfNewer(c, userParamEntry);
+                if (channelNameStateEntry != null) channelNameStateDAO.insert(c, channelNameStateEntry);
+                if (channelMetaUpdateEntry != null) channelNameStateDAO.updateMeta(c, channelMetaUpdateEntry);
+                if (notificationEntry != null) userNotificationsStateDAO.upsert(c, notificationEntry);
+
+                int msgType = block.type & 0xFFFF;
+                int msgSubType = block.subType & 0xFFFF;
+                Integer lineCode = be.getLineCode();
+                if (isPublicChannelPublication(msgType, msgSubType) && lineCode != null && lineCode > 0) {
+                    String channelName = channelReadStateDAO.resolvePublicChannelNameByRoot(c, blockchainName, lineCode);
+                    if (channelName != null && !channelName.isBlank()) {
+                        counterChangedLogins.addAll(channelReadStateDAO.incrementUnreadForSubscribers(
+                                c, blockchainName, channelName, MsgSubType.CONNECTION_FOLLOW, nowMs));
+                    }
                 }
 
-                if (channelNameStateEntry != null) {
-                    channelNameStateDAO.insert(c, channelNameStateEntry);
-                }
-
-                if (channelMetaUpdateEntry != null) {
-                    channelNameStateDAO.updateMeta(c, channelMetaUpdateEntry);
-                }
-
-                // Notification projection is part of the same SQL transaction as the block.
-                // If notification indexing fails, the block/state write is rolled back as well.
-                if (notificationEntry != null) {
-                    userNotificationsStateDAO.upsert(c, notificationEntry);
+                if (msgType == 3
+                        && msgSubType == (MsgSubType.CONNECTION_UNFOLLOW & 0xFFFF)
+                        && be.getToBchName() != null && !be.getToBchName().isBlank()
+                        && be.getToBlockNumber() != null && be.getToBlockNumber() > 0) {
+                    if (channelReadStateDAO.deleteForUnfollowTarget(
+                            c, be.getLogin(), be.getToBchName(), be.getToBlockNumber())) {
+                        counterChangedLogins.add(be.getLogin());
+                    }
                 }
 
                 c.commit();
-                committed = true;
             } catch (Exception e) {
-                try {
-                    c.rollback();
-                } catch (Exception ignored) {
-                }
-
-                if (!committed) {
-                    cleanupWriteArtifactsBestEffort(blockchainName);
-                }
-
-                if (e instanceof SQLException se) {
-                    throw se;
-                }
+                try { c.rollback(); } catch (Exception ignored) {}
+                if (e instanceof SQLException se) throw se;
                 throw new SQLException("appendBlockAndState failed", e);
             } finally {
-                try {
-                    c.setAutoCommit(true);
-                } catch (Exception ignored) {
-                }
+                try { c.setAutoCommit(true); } catch (Exception ignored) {}
             }
         }
-
-        // 3) После commit — атомарно подменяем основной файл.
-        try {
-            fs.atomicReplaceBlockchainFile(blockchainName);
-        } catch (RuntimeException e) {
-            // marker/check/tmp оставляем для startup-recovery
-            throw e;
-        }
-
-        // 4) После успешной подмены — чистим временные артефакты.
-        cleanupWriteArtifactsBestEffort(blockchainName);
+        return counterChangedLogins;
     }
 
-    private byte[] buildCandidateBlockchainBytes(String blockchainName, byte[] blockBytes) {
-        byte[] base;
-        try {
-            if (Files.exists(fs.resolveBlockchainPath(blockchainName))) {
-                base = fs.readBlockchain(blockchainName);
-            } else {
-                base = new byte[0];
-            }
-        } catch (RuntimeException e) {
-            throw e;
-        }
-
-        byte[] out = new byte[base.length + blockBytes.length];
-        System.arraycopy(base, 0, out, 0, base.length);
-        System.arraycopy(blockBytes, 0, out, base.length, blockBytes.length);
-        return out;
-    }
-
-    private void prepareWriteArtifacts(String blockchainName, int blockNumber, String blockHashHex, byte[] candidateBytes) {
-        fs.writeBlockchainTmp(blockchainName, candidateBytes);
-        fs.writeBlockchainWriteCheck(blockchainName, blockNumber, blockHashHex);
-        fs.writeBlockchainWritePendingMarker(blockchainName);
-    }
-
-    private void cleanupWriteArtifactsBestEffort(String blockchainName) {
-        deleteQuietly(() -> fs.deleteBlockchainWritePendingMarkerIfExists(blockchainName));
-        deleteQuietly(() -> fs.deleteBlockchainWriteCheckIfExists(blockchainName));
-        deleteQuietly(() -> fs.deleteBlockchainTmpFileIfExists(blockchainName));
-    }
-
-    private static void deleteQuietly(DeleteAction action) {
-        try {
-            action.run();
-        } catch (RuntimeException ignored) {
-        }
-    }
-
-    @FunctionalInterface
-    private interface DeleteAction {
-        void run();
+    private static boolean isPublicChannelPublication(int msgType, int msgSubType) {
+        if (msgType != 1) return false;
+        return msgSubType == (MsgSubType.TEXT_POST & 0xFFFF)
+                || msgSubType == (MsgSubType.TEXT_REPOST & 0xFFFF)
+                || msgSubType == (MsgSubType.TEXT_ENTRYPOINT & 0xFFFF)
+                || msgSubType == (MsgSubType.TEXT_EXERCISE & 0xFFFF)
+                || msgSubType == (MsgSubType.TEXT_SERVICE & 0xFFFF)
+                || msgSubType == (MsgSubType.TEXT_COURSE & 0xFFFF);
     }
 }

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/ChannelsReadSupport.java

@@ -144,38 +144,12 @@ final class ChannelsReadSupport {
         }
     }
 
-    static String userSettingsChannelKey(String ownerBch, String channelName) {
-        String bch = ownerBch == null ? "" : ownerBch.trim();
-        String name = channelName == null ? "" : channelName.trim();
-        return bch + "/" + name;
-    }
-
     static int countUnreadMessages(Connection c, String viewerLogin, String ownerBch, String channelName, int messagesCount) throws SQLException {
-        if (viewerLogin == null || viewerLogin.isBlank()) return 0;
-        String key = userSettingsChannelKey(ownerBch, channelName);
-        String sql = """
-            SELECT value_num
-            FROM user_settings
-            WHERE LOWER(login) = LOWER(?)
-              AND setting_type = ?
-              AND setting_key = ?
-            LIMIT 1
-            """;
-        long lastSeen = messagesCount;
-        try (PreparedStatement ps = c.prepareStatement(sql)) {
-            ps.setString(1, viewerLogin);
-            ps.setInt(2, 1);
-            ps.setString(3, key);
-            try (ResultSet rs = ps.executeQuery()) {
-                if (rs.next()) {
-                    long value = rs.getLong("value_num");
-                    if (!rs.wasNull()) lastSeen = value;
-                }
-            }
-        }
-        if (lastSeen < 0) lastSeen = 0;
-        if (lastSeen > messagesCount) return 0;
-        return Math.max(0, messagesCount - (int) lastSeen);
+        if (viewerLogin == null || viewerLogin.isBlank() || ownerBch == null || ownerBch.isBlank()
+                || channelName == null || channelName.isBlank()) return 0;
+        long unread = shine.db.dao.ChannelReadStateDAO.getInstance()
+                .getUnreadCount(c, viewerLogin, ownerBch, channelName);
+        return unread > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) Math.max(0L, unread);
     }
 
     static PostBlock loadLastPost(Connection c, String ownerBch, int lineCode) throws SQLException {
@@ -262,12 +236,13 @@ final class ChannelsReadSupport {
 
     static List<PostBlock> channelPosts(Connection c, String ownerBch, int lineCode, int limit, boolean asc) throws SQLException {
         String order = asc ? "ASC" : "DESC";
+        boolean bounded = limit > 0;
         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=?
             ORDER BY block_number
-            """ + order + " LIMIT ?";
+            """ + order + (bounded ? " LIMIT ?" : "");
         try (PreparedStatement ps = c.prepareStatement(sql)) {
             ps.setString(1, ownerBch);
             ps.setInt(2, MSG_TYPE_TEXT);
@@ -278,7 +253,7 @@ final class ChannelsReadSupport {
             ps.setInt(7, MsgSubType.TEXT_SERVICE);
             ps.setInt(8, MsgSubType.TEXT_COURSE);
             ps.setInt(9, lineCode);
-            ps.setInt(10, limit);
+            if (bounded) ps.setInt(10, limit);
             try (ResultSet rs = ps.executeQuery()) {
                 List<PostBlock> out = new ArrayList<>();
                 while (rs.next()) {

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetChannelMessages_Handler.java

@@ -34,9 +34,11 @@ public class Net_GetChannelMessages_Handler implements JsonMessageHandler {
             return NetExceptionResponseFactory.error(req, WireCodes.Status.BAD_REQUEST, "bad_fields", "Некорректные поля channel");
         }
 
-        int limit = req.getLimit() == null ? 30 : req.getLimit();
-        if (limit <= 0 || limit > 1000) {
-            return NetExceptionResponseFactory.error(req, WireCodes.Status.BAD_REQUEST, "limit_too_large", "Некорректный limit");
+        // limit is optional. null/0 means "return the whole channel".
+        // Positive values are kept for backwards-compatible callers that still want a bounded response.
+        int limit = req.getLimit() == null ? 0 : req.getLimit();
+        if (limit < 0) {
+            return NetExceptionResponseFactory.error(req, WireCodes.Status.BAD_REQUEST, "bad_limit", "Некорректный limit");
         }
 
         boolean asc = req.getSort() == null || !"desc".equalsIgnoreCase(req.getSort());
@@ -113,7 +115,7 @@ public class Net_GetChannelMessages_Handler implements JsonMessageHandler {
                     if (!asc) {
                         java.util.Collections.reverse(posts);
                     }
-                    if (posts.size() > limit) {
+                    if (limit > 0 && posts.size() > limit) {
                         posts = new ArrayList<>(posts.subList(0, limit));
                     }
                 }

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_GetMessageLikes_Handler.java

@@ -0,0 +1,101 @@
+package server.logic.ws_protocol.JSON.handlers.channels;
+
+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.channels.entyties.Net_GetMessageLikes_Request;
+import server.logic.ws_protocol.JSON.handlers.channels.entyties.Net_GetMessageLikes_Response;
+import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory;
+import server.logic.ws_protocol.WireCodes;
+import shine.db.DbController;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Net_GetMessageLikes_Handler implements JsonMessageHandler {
+    private static final Logger log = LoggerFactory.getLogger(Net_GetMessageLikes_Handler.class);
+
+    @Override
+    public Net_Response handle(Net_Request baseRequest, ConnectionContext ctx) {
+        Net_GetMessageLikes_Request req = (Net_GetMessageLikes_Request) baseRequest;
+        Net_GetMessageLikes_Request.MessageSelector message = req.getMessage();
+        if (message == null || message.getBlockchainName() == null || message.getBlockchainName().isBlank()
+                || message.getBlockNumber() == null || message.getBlockNumber() < 0
+                || message.getBlockHash() == null || message.getBlockHash().isBlank()) {
+            return NetExceptionResponseFactory.error(req, WireCodes.Status.BAD_REQUEST, "bad_fields", "Некорректные поля message");
+        }
+
+        final byte[] blockHash;
+        try {
+            blockHash = ChannelsReadSupport.hexToBytes(message.getBlockHash());
+        } catch (Exception e) {
+            return NetExceptionResponseFactory.error(req, WireCodes.Status.BAD_REQUEST, "bad_hash", "Некорректный blockHash");
+        }
+        if (blockHash == null || blockHash.length == 0) {
+            return NetExceptionResponseFactory.error(req, WireCodes.Status.BAD_REQUEST, "bad_hash", "Некорректный blockHash");
+        }
+
+        try (Connection c = DbController.getInstance().getConnection()) {
+            String sql = """
+                SELECT rs.from_login,
+                       COALESCE(ups.first_name, '') AS first_name,
+                       COALESCE(ups.last_name, '') AS last_name,
+                       COALESCE(ups.ava_ar, '') AS avatar_ar,
+                       COALESCE(ups.account_role, 'unknown') AS account_role,
+                       COALESCE(ups.shine_status, 'unknown') AS shine_status
+                FROM reactions_state rs
+                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 rs.to_block_number = ?
+                  AND rs.to_block_hash = ?
+                ORDER BY LOWER(rs.from_login)
+                """;
+
+            List<Net_GetMessageLikes_Response.UserItem> shining = new ArrayList<>();
+            List<Net_GetMessageLikes_Response.UserItem> official = new ArrayList<>();
+            List<Net_GetMessageLikes_Response.UserItem> others = new ArrayList<>();
+            try (PreparedStatement ps = c.prepareStatement(sql)) {
+                ps.setString(1, message.getBlockchainName().trim());
+                ps.setInt(2, message.getBlockNumber());
+                ps.setBytes(3, blockHash);
+                try (ResultSet rs = ps.executeQuery()) {
+                    while (rs.next()) {
+                        Net_GetMessageLikes_Response.UserItem user = new Net_GetMessageLikes_Response.UserItem();
+                        user.setLogin(rs.getString("from_login"));
+                        user.setFirstName(rs.getString("first_name"));
+                        user.setLastName(rs.getString("last_name"));
+                        user.setAvatarAr(rs.getString("avatar_ar"));
+
+                        boolean isOfficial = "primary".equalsIgnoreCase(rs.getString("account_role"));
+                        boolean isShining = "shining".equalsIgnoreCase(rs.getString("shine_status"));
+                        if (isOfficial && isShining) shining.add(user);
+                        else if (isOfficial) official.add(user);
+                        else others.add(user);
+                    }
+
+                    Net_GetMessageLikes_Response resp = new Net_GetMessageLikes_Response();
+                    resp.setOp(req.getOp());
+                    resp.setRequestId(req.getRequestId());
+                    resp.setStatus(WireCodes.Status.OK);
+                    resp.setShining(shining);
+                    resp.setOfficial(official);
+                    resp.setOthers(others);
+                    resp.setTotal(shining.size() + official.size() + others.size());
+                    resp.setTruncated(false);
+                    return resp;
+                }
+            }
+        } catch (Exception e) {
+            log.error("GetMessageLikes failed", e);
+            return NetExceptionResponseFactory.error(req, WireCodes.Status.INTERNAL_ERROR, "internal_error", "Внутренняя ошибка сервера");
+        }
+    }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_ListSubscriptionsFeed_Handler.java

@@ -12,6 +12,7 @@ import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory;
 import server.logic.ws_protocol.WireCodes;
 import shine.db.MsgSubType;
 import shine.db.DbController;
+import shine.db.dao.ChannelReadStateDAO;
 
 import java.sql.Connection;
 import java.sql.PreparedStatement;
@@ -81,11 +82,15 @@ public class Net_ListSubscriptionsFeed_Handler implements JsonMessageHandler {
             channelRef.setChannelRoot(rootRef);
 
             row.setChannel(channelRef);
-            row.setMessagesCount(ChannelsReadSupport.countPosts(c, key.ownerBch, key.rootNumber));
+            int messagesCount = ChannelsReadSupport.countPosts(c, key.ownerBch, key.rootNumber);
+            row.setMessagesCount(messagesCount);
             boolean ownChannel = key.ownerLogin != null && key.ownerLogin.equalsIgnoreCase(viewerLogin);
-            row.setUnreadCount(ownChannel
-                    ? 0
-                    : ChannelsReadSupport.countUnreadMessages(c, viewerLogin, key.ownerBch, meta.channelName, row.getMessagesCount()));
+            ChannelReadStateDAO.ReadState readState = ownChannel || meta.channelName == null
+                    ? null
+                    : ChannelReadStateDAO.getInstance().get(c, viewerLogin, key.ownerBch, meta.channelName);
+            row.setReadStateInitialized(readState != null);
+            row.setReadCount(readState == null ? 0L : Math.min(messagesCount, Math.max(0L, readState.readCount())));
+            row.setUnreadCount(readState == null ? 0 : (int) Math.min(Integer.MAX_VALUE, readState.unreadCount()));
 
             ChannelsReadSupport.PostBlock lastPost = ChannelsReadSupport.loadLastPost(c, key.ownerBch, key.rootNumber);
             if (lastPost != null) {

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/Net_SetChannelReadState_Handler.java

@@ -0,0 +1,145 @@
+package server.logic.ws_protocol.JSON.handlers.channels;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+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.channels.entyties.Net_SetChannelReadState_Request;
+import server.logic.ws_protocol.JSON.handlers.channels.entyties.Net_SetChannelReadState_Response;
+import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory;
+import server.logic.ws_protocol.WireCodes;
+import shine.db.DbController;
+import shine.db.MsgSubType;
+import shine.db.dao.ChannelReadStateDAO;
+import utils.config.ShineSignatureConstants;
+import utils.crypto.Ed25519Util;
+
+import java.nio.charset.StandardCharsets;
+import java.sql.Connection;
+
+/** Accepts the signed client read watermark for one followed public channel. */
+public final class Net_SetChannelReadState_Handler implements JsonMessageHandler {
+    private static final Logger log = LoggerFactory.getLogger(Net_SetChannelReadState_Handler.class);
+    private static final long MAX_FUTURE_SKEW_MS = 5 * 60_000L;
+
+    @Override
+    public Net_Response handle(Net_Request baseRequest, ConnectionContext ctx) {
+        Net_SetChannelReadState_Request req = (Net_SetChannelReadState_Request) baseRequest;
+        if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getCurrentUser() == null) {
+            return NetExceptionResponseFactory.error(req, WireCodes.Status.UNVERIFIED,
+                    "NOT_AUTHENTICATED", "Требуется авторизация");
+        }
+        if (req.getLogin() == null || req.getLogin().isBlank()
+                || req.getOwner_bch_name() == null || req.getOwner_bch_name().isBlank()
+                || req.getChannel_name() == null || req.getChannel_name().isBlank()
+                || req.getRead_count() == null || req.getRead_count() < 0
+                || req.getTime_ms() == null || req.getTime_ms() <= 0
+                || req.getClient_key() == null || req.getClient_key().isBlank()
+                || req.getSignature() == null || req.getSignature().isBlank()) {
+            return NetExceptionResponseFactory.error(req, WireCodes.Status.BAD_REQUEST,
+                    "BAD_FIELDS", "Некорректные поля ChannelReadState");
+        }
+
+        String authenticatedLogin = String.valueOf(ctx.getCurrentUser().getLogin()).trim();
+        String login = req.getLogin().trim();
+        String ownerBch = req.getOwner_bch_name().trim();
+        String channelName = req.getChannel_name().trim();
+        long readCount = req.getRead_count();
+        long timeMs = req.getTime_ms();
+        String clientKeyB64 = req.getClient_key().trim();
+        String signatureB64 = req.getSignature().trim();
+
+        if (!authenticatedLogin.equalsIgnoreCase(login)) {
+            return NetExceptionResponseFactory.error(req, WireCodes.Status.UNVERIFIED,
+                    "LOGIN_MISMATCH", "Состояние чтения принадлежит другому пользователю");
+        }
+        long nowMs = System.currentTimeMillis();
+        if (timeMs > nowMs + MAX_FUTURE_SKEW_MS) {
+            return NetExceptionResponseFactory.error(req, WireCodes.Status.UNVERIFIED,
+                    "BAD_TIME", "Некорректное время подписи");
+        }
+
+        try {
+            byte[] pubKey32;
+            byte[] sig64;
+            try {
+                pubKey32 = Base64Ws.decodeLen(clientKeyB64, 32, "client_key");
+                sig64 = Base64Ws.decodeLen(signatureB64, 64, "signature");
+            } catch (IllegalArgumentException e) {
+                return NetExceptionResponseFactory.error(req, WireCodes.Status.BAD_REQUEST,
+                        "BAD_BASE64", "client_key/signature должны быть Base64");
+            }
+
+            String userClientKey = String.valueOf(ctx.getCurrentUser().getClientKey() == null
+                    ? "" : ctx.getCurrentUser().getClientKey()).trim();
+            if (userClientKey.isBlank() || !userClientKey.equals(clientKeyB64)) {
+                return NetExceptionResponseFactory.error(req, 403,
+                        "DEVICE_KEY_MISMATCH", "client_key не соответствует пользователю");
+            }
+
+            String signText = ShineSignatureConstants.CHANNEL_READ_STATE_PREFIX
+                    + escapePart(login) + '|'
+                    + escapePart(ownerBch) + '|'
+                    + escapePart(channelName) + '|'
+                    + timeMs + '|'
+                    + readCount;
+            if (!Ed25519Util.verify(signText.getBytes(StandardCharsets.UTF_8), sig64, pubKey32)) {
+                return NetExceptionResponseFactory.error(req, WireCodes.Status.UNVERIFIED,
+                        "INVALID_SIGNATURE", "Подпись состояния чтения канала не прошла проверку");
+            }
+
+            ChannelReadStateDAO dao = ChannelReadStateDAO.getInstance();
+            ChannelReadStateDAO.UpsertResult result;
+            try (Connection c = DbController.getInstance().getConnection()) {
+                if (!dao.hasActiveSubscription(c, authenticatedLogin, ownerBch, channelName,
+                        MsgSubType.CONNECTION_FOLLOW)) {
+                    return NetExceptionResponseFactory.error(req, 409,
+                            "CHANNEL_NOT_FOLLOWED", "Пользователь не подписан на этот канал");
+                }
+                String ownerLogin = dao.resolveOwnerLogin(c, ownerBch, channelName);
+                Integer channelRoot = dao.resolvePublicChannelRootByName(c, ownerBch, channelName);
+                if (ownerLogin == null || ownerLogin.isBlank() || channelRoot == null) {
+                    return NetExceptionResponseFactory.error(req, 404,
+                            "CHANNEL_NOT_FOUND", "Канал не найден");
+                }
+
+                // Never persist a watermark beyond the number of messages that really exists.
+                // Without this guard, one buggy/malicious oversized read_count would be monotonic
+                // and could make all future unread counters impossible to clear correctly.
+                long actualMessagesCount = ChannelsReadSupport.countPosts(c, ownerBch, channelRoot);
+                long effectiveReadCount = Math.min(readCount, actualMessagesCount);
+
+                result = dao.upsertSignedReadIfNewer(c,
+                        authenticatedLogin, ownerLogin, ownerBch, channelName,
+                        effectiveReadCount, timeMs, clientKeyB64, signatureB64, nowMs);
+            }
+
+            Net_SetChannelReadState_Response resp = new Net_SetChannelReadState_Response();
+            resp.setOp(req.getOp());
+            resp.setRequestId(req.getRequestId());
+            resp.setStatus(WireCodes.Status.OK);
+            resp.setLogin(authenticatedLogin);
+            resp.setOwner_bch_name(ownerBch);
+            resp.setChannel_name(channelName);
+            resp.setRead_count(result.readCount());
+            resp.setUnread_count(result.unreadCount());
+            resp.setTime_ms(timeMs);
+            resp.setApplied(result.applied());
+            if (result.applied()) UserCountersSupport.pushChanged(authenticatedLogin);
+            return resp;
+        } catch (Exception e) {
+            log.error("SetChannelReadState failed", e);
+            return NetExceptionResponseFactory.error(req, WireCodes.Status.INTERNAL_ERROR,
+                    "INTERNAL_ERROR", NetExceptionResponseFactory.detailedMessage(
+                            "Внутренняя ошибка SetChannelReadState", e));
+        }
+    }
+
+    private static String escapePart(String value) {
+        String s = String.valueOf(value == null ? "" : value);
+        return s.replace("\\", "\\\\").replace("|", "\\|");
+    }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/UserCountersSupport.java

@@ -6,8 +6,8 @@ import server.logic.ws_protocol.JSON.ActiveConnectionsRegistry;
 import server.logic.ws_protocol.JSON.ConnectionContext;
 import server.logic.ws_protocol.JSON.push.WsEventSender;
 import shine.db.DbController;
-import shine.db.MsgSubType;
 import shine.db.dao.UserNotificationSeenStateDAO;
+import shine.db.dao.ChannelReadStateDAO;
 import shine.db.dao.UserNotificationsStateDAO;
 
 import java.sql.Connection;
@@ -89,28 +89,6 @@ public final class UserCountersSupport {
     }
 
     private static long countChannelsUnread(Connection c, String login) throws Exception {
-        String sql = """
-            SELECT cs.to_bch_name, COALESCE(cs.to_block_number,0) AS root_number
-            FROM connections_state cs
-            WHERE LOWER(cs.login)=LOWER(?) AND cs.rel_type=?
-            """;
-        long total = 0L;
-        try (PreparedStatement ps = c.prepareStatement(sql)) {
-            ps.setString(1, login);
-            ps.setInt(2, MsgSubType.CONNECTION_FOLLOW);
-            try (ResultSet rs = ps.executeQuery()) {
-                while (rs.next()) {
-                    String ownerBch = rs.getString("to_bch_name");
-                    int rootNumber = rs.getInt("root_number");
-                    if (ownerBch == null || ownerBch.isBlank()) continue;
-                    ChannelsReadSupport.ChannelMeta meta = ChannelsReadSupport.detectChannelMeta(c, ownerBch, rootNumber);
-                    if (meta == null || meta.channelName == null || meta.channelName.isBlank()) continue;
-                    if (meta.channelTypeCode == 0 || "stories".equalsIgnoreCase(meta.channelName)) continue;
-                    int messages = ChannelsReadSupport.countPosts(c, ownerBch, rootNumber);
-                    total += Math.max(0, ChannelsReadSupport.countUnreadMessages(c, login, ownerBch, meta.channelName, messages));
-                }
-            }
-        }
-        return total;
+        return ChannelReadStateDAO.getInstance().sumUnreadCount(c, login);
     }
 }

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/entyties/Net_GetMessageLikes_Request.java

@@ -0,0 +1,29 @@
+package server.logic.ws_protocol.JSON.handlers.channels.entyties;
+
+import server.logic.ws_protocol.JSON.entyties.Net_Request;
+
+public class Net_GetMessageLikes_Request extends Net_Request {
+    private MessageSelector message;
+    private Integer limit;
+
+    public MessageSelector getMessage() { return message; }
+    public void setMessage(MessageSelector message) { this.message = message; }
+
+    public Integer getLimit() { return limit; }
+    public void setLimit(Integer limit) { this.limit = limit; }
+
+    public static class MessageSelector {
+        private String blockchainName;
+        private Integer blockNumber;
+        private String blockHash;
+
+        public String getBlockchainName() { return blockchainName; }
+        public void setBlockchainName(String blockchainName) { this.blockchainName = blockchainName; }
+
+        public Integer getBlockNumber() { return blockNumber; }
+        public void setBlockNumber(Integer blockNumber) { this.blockNumber = blockNumber; }
+
+        public String getBlockHash() { return blockHash; }
+        public void setBlockHash(String blockHash) { this.blockHash = blockHash; }
+    }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/entyties/Net_GetMessageLikes_Response.java

@@ -0,0 +1,40 @@
+package server.logic.ws_protocol.JSON.handlers.channels.entyties;
+
+import server.logic.ws_protocol.JSON.entyties.Net_Response;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Net_GetMessageLikes_Response extends Net_Response {
+    private List<UserItem> shining = new ArrayList<>();
+    private List<UserItem> official = new ArrayList<>();
+    private List<UserItem> others = new ArrayList<>();
+    private int total;
+    private boolean truncated;
+
+    public List<UserItem> getShining() { return shining; }
+    public void setShining(List<UserItem> shining) { this.shining = shining; }
+    public List<UserItem> getOfficial() { return official; }
+    public void setOfficial(List<UserItem> official) { this.official = official; }
+    public List<UserItem> getOthers() { return others; }
+    public void setOthers(List<UserItem> others) { this.others = others; }
+    public int getTotal() { return total; }
+    public void setTotal(int total) { this.total = total; }
+    public boolean isTruncated() { return truncated; }
+    public void setTruncated(boolean truncated) { this.truncated = truncated; }
+
+    public static class UserItem {
+        private String login;
+        private String firstName;
+        private String lastName;
+        private String avatarAr;
+
+        public String getLogin() { return login; }
+        public void setLogin(String login) { this.login = login; }
+        public String getFirstName() { return firstName; }
+        public void setFirstName(String firstName) { this.firstName = firstName; }
+        public String getLastName() { return lastName; }
+        public void setLastName(String lastName) { this.lastName = lastName; }
+        public String getAvatarAr() { return avatarAr; }
+        public void setAvatarAr(String avatarAr) { this.avatarAr = avatarAr; }
+    }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/entyties/Net_ListSubscriptionsFeed_Response.java

@@ -26,7 +26,9 @@ public class Net_ListSubscriptionsFeed_Response extends Net_Response {
     public static class ChannelSummary {
         private ChannelRef channel;
         private int messagesCount;
+        private long readCount;
         private int unreadCount;
+        private boolean readStateInitialized;
         private LastMessage lastMessage;
 
         public ChannelRef getChannel() { return channel; }
@@ -35,9 +37,15 @@ public class Net_ListSubscriptionsFeed_Response extends Net_Response {
         public int getMessagesCount() { return messagesCount; }
         public void setMessagesCount(int messagesCount) { this.messagesCount = messagesCount; }
 
+        public long getReadCount() { return readCount; }
+        public void setReadCount(long readCount) { this.readCount = readCount; }
+
         public int getUnreadCount() { return unreadCount; }
         public void setUnreadCount(int unreadCount) { this.unreadCount = unreadCount; }
 
+        public boolean isReadStateInitialized() { return readStateInitialized; }
+        public void setReadStateInitialized(boolean readStateInitialized) { this.readStateInitialized = readStateInitialized; }
+
         public LastMessage getLastMessage() { return lastMessage; }
         public void setLastMessage(LastMessage lastMessage) { this.lastMessage = lastMessage; }
     }

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/entyties/Net_SetChannelReadState_Request.java

@@ -0,0 +1,34 @@
+package server.logic.ws_protocol.JSON.handlers.channels.entyties;
+
+import server.logic.ws_protocol.JSON.entyties.Net_Request;
+
+public class Net_SetChannelReadState_Request extends Net_Request {
+    private String login;
+    private String owner_bch_name;
+    private String channel_name;
+    private Long read_count;
+    private Long time_ms;
+    private String client_key;
+    private String signature;
+
+    public String getLogin() { return login; }
+    public void setLogin(String login) { this.login = login; }
+
+    public String getOwner_bch_name() { return owner_bch_name; }
+    public void setOwner_bch_name(String owner_bch_name) { this.owner_bch_name = owner_bch_name; }
+
+    public String getChannel_name() { return channel_name; }
+    public void setChannel_name(String channel_name) { this.channel_name = channel_name; }
+
+    public Long getRead_count() { return read_count; }
+    public void setRead_count(Long read_count) { this.read_count = read_count; }
+
+    public Long getTime_ms() { return time_ms; }
+    public void setTime_ms(Long time_ms) { this.time_ms = time_ms; }
+
+    public String getClient_key() { return client_key; }
+    public void setClient_key(String client_key) { this.client_key = client_key; }
+
+    public String getSignature() { return signature; }
+    public void setSignature(String signature) { this.signature = signature; }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/channels/entyties/Net_SetChannelReadState_Response.java

@@ -0,0 +1,34 @@
+package server.logic.ws_protocol.JSON.handlers.channels.entyties;
+
+import server.logic.ws_protocol.JSON.entyties.Net_Response;
+
+public class Net_SetChannelReadState_Response extends Net_Response {
+    private String login;
+    private String owner_bch_name;
+    private String channel_name;
+    private Long read_count;
+    private Long unread_count;
+    private Long time_ms;
+    private Boolean applied;
+
+    public String getLogin() { return login; }
+    public void setLogin(String login) { this.login = login; }
+
+    public String getOwner_bch_name() { return owner_bch_name; }
+    public void setOwner_bch_name(String owner_bch_name) { this.owner_bch_name = owner_bch_name; }
+
+    public String getChannel_name() { return channel_name; }
+    public void setChannel_name(String channel_name) { this.channel_name = channel_name; }
+
+    public Long getRead_count() { return read_count; }
+    public void setRead_count(Long read_count) { this.read_count = read_count; }
+
+    public Long getUnread_count() { return unread_count; }
+    public void setUnread_count(Long unread_count) { this.unread_count = unread_count; }
+
+    public Long getTime_ms() { return time_ms; }
+    public void setTime_ms(Long time_ms) { this.time_ms = time_ms; }
+
+    public Boolean getApplied() { return applied; }
+    public void setApplied(Boolean applied) { this.applied = applied; }
+}

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/userSettings/Net_UpsertUserSetting_Handler.java

@@ -9,7 +9,6 @@ import server.logic.ws_protocol.JSON.entyties.Net_Response;
 import server.logic.ws_protocol.JSON.handlers.JsonMessageHandler;
 import server.logic.ws_protocol.JSON.handlers.userSettings.entyties.Net_UpsertUserSetting_Request;
 import server.logic.ws_protocol.JSON.handlers.userSettings.entyties.Net_UpsertUserSetting_Response;
-import server.logic.ws_protocol.JSON.handlers.channels.UserCountersSupport;
 import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory;
 import server.logic.ws_protocol.WireCodes;
 import shine.db.DbController;
@@ -101,9 +100,6 @@ public class Net_UpsertUserSetting_Handler implements JsonMessageHandler {
                 resp.setSetting_type(settingType);
                 resp.setSetting_key(settingKey);
                 resp.setTime_ms(timeMs);
-                if (settingType == 1) {
-                    UserCountersSupport.pushChanged(login);
-                }
                 return resp;
             }
         } catch (SQLException e) {

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/messages/SignedMessagesRealtime.java

@@ -147,7 +147,7 @@ public final class SignedMessagesRealtime {
             if (isBlank(session.getPushEndpoint()) || isBlank(session.getPushP256dhKey()) || isBlank(session.getPushAuthKey())) {
                 return false;
             }
-            String text = "Вам пришло новое личное сообщение от " + message.getFromLogin() + ".";
+            String text = "Новое сообщение от " + message.getFromLogin();
             String payload = "{\"kind\":\"new_message\",\"fromLogin\":\"" + jsonEscape(message.getFromLogin()) + "\",\"text\":\"" + jsonEscape(text) + "\"}";
             return WebPushSender.sendBase64Payload(
                     session.getPushEndpoint(),

SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/push/WebPushSender.java

@@ -3,6 +3,7 @@ package server.logic.ws_protocol.JSON.push;
 import nl.martijndwars.webpush.Notification;
 import nl.martijndwars.webpush.PushService;
 import nl.martijndwars.webpush.Subscription;
+import nl.martijndwars.webpush.Urgency;
 import org.jose4j.lang.JoseException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -61,7 +62,7 @@ public final class WebPushSender {
                     endpoint,
                     new Subscription.Keys(p256dhKey, authKey)
             );
-            Notification notification = new Notification(subscription, payloadB64);
+            Notification notification = new Notification(subscription, payloadB64, Urgency.HIGH);
             var response = service().send(notification);
             int code = response.getStatusLine().getStatusCode();
             return code >= 200 && code < 300;

SHiNE-server/shine-server-net-protocol/src/main/java/server/sync/BlockchainResyncGuard.java

@@ -4,7 +4,6 @@ import java.util.HashSet;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
-import utils.files.FileStoreUtil;
 
 /**
  * In-memory guard для цепочек, которые сейчас находятся в полном resync.
@@ -39,10 +38,7 @@ public final class BlockchainResyncGuard {
         if (isBypassed(key)) {
             return false;
         }
-        if (ACTIVE.contains(key)) {
-            return true;
-        }
-        return FileStoreUtil.getInstance().existsBlockchainResyncMarker(key);
+        return ACTIVE.contains(key);
     }
 
     public static <T> T withBypass(String blockchainName, ThrowingSupplier<T> supplier) throws Exception {

SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/codec/ShineUsersCodec.java

@@ -59,6 +59,9 @@ public final class ShineUsersCodec {
     private static final int BLOCK_TYPE_TRUSTED_STATE =
             70;
 
+    private static final int BLOCK_TYPE_ARCHIVE_HEAD =
+            100;
+
     private static final int BLOCK_VERSION_0 =
             0;
 
@@ -306,6 +309,12 @@ public final class ShineUsersCodec {
         int trustedCount =
                 0;
 
+        String archiveHeadTxId =
+                "";
+
+        String archiveHeadHash =
+                "";
+
         for (int i = 0; i < blocksCount; i++) {
 
             int blockType =
@@ -455,6 +464,13 @@ public final class ShineUsersCodec {
                         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 block type: " + blockType
@@ -484,6 +500,8 @@ public final class ShineUsersCodec {
                 lastBlockHash,
                 lastBlockSignature,
                 arweaveTxId,
+                archiveHeadTxId,
+                archiveHeadHash,
                 isServer,
                 addressFormatType,
                 addressFormatVersion,
@@ -520,7 +538,9 @@ public final class ShineUsersCodec {
                 mutation.createdAtMs(),
                 mutation.createdAtMs(),
                 toHex(ZERO_HASH),
-                paidLimitBytes
+                paidLimitBytes,
+                mutation.fields().archiveHeadSupplied() ? mutation.fields().archiveHeadTxId() : "",
+                mutation.fields().archiveHeadSupplied() ? mutation.fields().archiveHeadHash() : ""
         );
     }
 
@@ -535,6 +555,13 @@ public final class ShineUsersCodec {
                 previous.paidLimitBytes()
                         + mutation.additionalLimit();
 
+        String archiveTx = mutation.fields().archiveHeadSupplied()
+                ? mutation.fields().archiveHeadTxId()
+                : previous.archiveHeadTxId();
+        String archiveHash = mutation.fields().archiveHeadSupplied()
+                ? mutation.fields().archiveHeadHash()
+                : previous.archiveHeadHash();
+
         return buildSnapshot(
                 mutation,
                 mutation.version(),
@@ -543,7 +570,9 @@ public final class ShineUsersCodec {
                 mutation.createdAtMs(),
                 mutation.updatedAtMs(),
                 toHex(mutation.prevHash()),
-                paidLimitBytes
+                paidLimitBytes,
+                archiveTx,
+                archiveHash
         );
     }
 
@@ -617,10 +646,13 @@ public final class ShineUsersCodec {
         pushFixed(out, prevHash);
         pushStringU8(out, loginBytes);
 
+        boolean hasArchiveHead =
+                snapshot.archiveHeadTxId() != null
+                        && !snapshot.archiveHeadTxId().isBlank();
+
         int blocksCount =
-                snapshot.isServer()
-                        ? 8
-                        : 7;
+                (snapshot.isServer() ? 8 : 7)
+                        + (hasArchiveHead ? 1 : 0);
 
         out.add((byte) blocksCount);
 
@@ -695,6 +727,18 @@ public final class ShineUsersCodec {
         out.add((byte) BLOCK_VERSION_0);
         out.add((byte) snapshot.trustedCount());
 
+        if (hasArchiveHead) {
+            byte[] txId = Base64.getUrlDecoder().decode(snapshot.archiveHeadTxId());
+            byte[] archiveHash = fromHex(snapshot.archiveHeadHash());
+            if (txId.length != 32 || archiveHash.length != 32) {
+                throw new IllegalArgumentException("Archive head должен содержать txId/hash по 32 байта");
+            }
+            out.add((byte) BLOCK_TYPE_ARCHIVE_HEAD);
+            out.add((byte) BLOCK_VERSION_0);
+            pushFixed(out, txId);
+            pushFixed(out, archiveHash);
+        }
+
         int recordLength =
                 out.size() + 64;
 
@@ -871,6 +915,8 @@ public final class ShineUsersCodec {
         UserFields fields =
                 parseFields(reader);
 
+        fields = parseOptionalArchiveExtension(reader, fields);
+
         String recordSignature =
                 Base58Util.encode(
                         reader.readFixed(64)
@@ -1008,7 +1054,35 @@ public final class ShineUsersCodec {
                 List.copyOf(accessServers),
                 sessionsMode,
                 List.copyOf(sessions),
-                trustedCount
+                trustedCount,
+                false,
+                "",
+                ""
+        );
+    }
+
+    private static UserFields parseOptionalArchiveExtension(Reader reader, UserFields fields) {
+        if (reader.remaining() == 64) {
+            return fields;
+        }
+        if (reader.remaining() < 65) {
+            throw new IllegalArgumentException("Некорректная archive extension в update_user_pda");
+        }
+        int present = reader.readU8();
+        String tx = "";
+        String hash = "";
+        if (present == 1) {
+            tx = Base64.getUrlEncoder().withoutPadding().encodeToString(reader.readFixed(32));
+            hash = toHex(reader.readFixed(32));
+        } else if (present != 0) {
+            throw new IllegalArgumentException("Некорректный archive head marker: " + present);
+        }
+        return new UserFields(
+                fields.clientKey(), fields.blockchainKey(), fields.blockchainName(), fields.usedBytes(),
+                fields.lastBlockNumber(), fields.lastBlockHash(), fields.lastBlockSignature(), fields.arweaveTxId(),
+                fields.isServer(), fields.addressFormatType(), fields.addressFormatVersion(), fields.serverAddress(),
+                fields.syncServers(), fields.accessServers(), fields.sessionsMode(), fields.sessions(), fields.trustedCount(),
+                true, tx, hash
         );
     }
 
@@ -1020,7 +1094,9 @@ public final class ShineUsersCodec {
             long createdAtMs,
             long updatedAtMs,
             String prevRecordHash,
-            long paidLimitBytes
+            long paidLimitBytes,
+            String archiveHeadTxId,
+            String archiveHeadHash
     ) {
 
         UserFields fields =
@@ -1044,6 +1120,8 @@ public final class ShineUsersCodec {
                         fields.lastBlockHash(),
                         fields.lastBlockSignature(),
                         fields.arweaveTxId(),
+                        archiveHeadTxId == null ? "" : archiveHeadTxId,
+                        archiveHeadHash == null ? "" : archiveHeadHash,
                         fields.isServer(),
                         fields.addressFormatType(),
                         fields.addressFormatVersion(),
@@ -1266,6 +1344,10 @@ public final class ShineUsersCodec {
         ) {
             cursor += bytes;
         }
+
+        private int remaining() {
+            return data.length - cursor;
+        }
     }
 
     public enum TxKind {
@@ -1327,7 +1409,10 @@ public final class ShineUsersCodec {
             List<String> accessServers,
             int sessionsMode,
             List<UserSessionSnapshot> sessions,
-            int trustedCount
+            int trustedCount,
+            boolean archiveHeadSupplied,
+            String archiveHeadTxId,
+            String archiveHeadHash
     ) {
     }
 
@@ -1389,6 +1474,8 @@ public final class ShineUsersCodec {
             String lastBlockHash,
             String lastBlockSignature,
             String arweaveTxId,
+            String archiveHeadTxId,
+            String archiveHeadHash,
             boolean isServer,
             int addressFormatType,
             int addressFormatVersion,
@@ -1424,6 +1511,8 @@ public final class ShineUsersCodec {
                     lastBlockHash,
                     lastBlockSignature,
                     arweaveTxId,
+                    archiveHeadTxId,
+                    archiveHeadHash,
                     isServer,
                     addressFormatType,
                     addressFormatVersion,

SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/service/SolanaUsersSyncService.java

@@ -629,7 +629,7 @@ public final class SolanaUsersSyncService
                                 account.address(),
                                 account.slot(),
                                 account.dataBase64(),
-                                state.lastSeenSignature()
+                                ""
                         )
                 );
             } catch (Exception ignored) {

SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/storage/postgres/PostgresStorageRepository.java

@@ -299,13 +299,7 @@ public final class PostgresStorageRepository
 
             connection.setAutoCommit(false);
 
-            try (Statement statement =
-                         connection.createStatement()) {
-
-                statement.executeUpdate(
-                        "TRUNCATE TABLE solana_user_pda_current"
-                );
-
+            try {
                 upsertCurrentSnapshots(
                         connection,
                         snapshots
@@ -425,13 +419,13 @@ public final class PostgresStorageRepository
                         "record_number, recovery_key, root_key, client_key, " +
                         "blockchain_name, blockchain_key, paid_limit_bytes, " +
                         "used_bytes, last_block_number, last_block_hash, " +
-                        "last_block_signature, arweave_tx_id, is_server, " +
+                        "last_block_signature, arweave_tx_id, archive_head_tx_id, archive_head_hash, is_server, " +
                         "address_format_type, address_format_version, " +
                         "server_address, sync_servers_json, access_servers_json, " +
                         "sessions_mode, sessions_json, trusted_count, " +
                         "created_at_ms, updated_at_ms, prev_record_hash, " +
                         "record_signature, raw_data_base64, saved_at_ms" +
-                        ") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) " +
+                        ") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) " +
                         "ON CONFLICT (pda_address, record_number) DO NOTHING";
 
         try (PreparedStatement statement =
@@ -470,13 +464,13 @@ public final class PostgresStorageRepository
                         "recovery_key, root_key, client_key, blockchain_name, " +
                         "blockchain_key, paid_limit_bytes, used_bytes, " +
                         "last_block_number, last_block_hash, last_block_signature, " +
-                        "arweave_tx_id, is_server, address_format_type, " +
+                        "arweave_tx_id, archive_head_tx_id, archive_head_hash, is_server, address_format_type, " +
                         "address_format_version, server_address, sync_servers_json, " +
                         "access_servers_json, sessions_mode, sessions_json, " +
                         "trusted_count, created_at_ms, updated_at_ms, " +
                         "prev_record_hash, record_signature, raw_data_base64, " +
                         "first_seen_at_ms, last_synced_at_ms" +
-                        ") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) " +
+                        ") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) " +
                         "ON CONFLICT (pda_address) DO UPDATE SET " +
                         "login = EXCLUDED.login, " +
                         "normalized_login = EXCLUDED.normalized_login, " +
@@ -494,6 +488,16 @@ public final class PostgresStorageRepository
                         "last_block_hash = EXCLUDED.last_block_hash, " +
                         "last_block_signature = EXCLUDED.last_block_signature, " +
                         "arweave_tx_id = EXCLUDED.arweave_tx_id, " +
+                        "archive_imported = CASE WHEN " +
+                        "EXCLUDED.archive_head_tx_id IS DISTINCT FROM solana_user_pda_current.archive_head_tx_id " +
+                        "OR EXCLUDED.archive_head_hash IS DISTINCT FROM solana_user_pda_current.archive_head_hash " +
+                        "THEN FALSE ELSE solana_user_pda_current.archive_imported END, " +
+                        "archive_last_imported_tx_id = CASE WHEN " +
+                        "EXCLUDED.archive_head_tx_id = solana_user_pda_current.archive_head_tx_id " +
+                        "AND EXCLUDED.archive_head_hash IS DISTINCT FROM solana_user_pda_current.archive_head_hash " +
+                        "THEN '' ELSE solana_user_pda_current.archive_last_imported_tx_id END, " +
+                        "archive_head_tx_id = EXCLUDED.archive_head_tx_id, " +
+                        "archive_head_hash = EXCLUDED.archive_head_hash, " +
                         "is_server = EXCLUDED.is_server, " +
                         "address_format_type = EXCLUDED.address_format_type, " +
                         "address_format_version = EXCLUDED.address_format_version, " +
@@ -536,141 +540,41 @@ public final class PostgresStorageRepository
             ShineUsersCodec.UserPdaSnapshot snapshot,
             long nowMs
     ) throws Exception {
-
-        statement.setString(
-                1,
-                snapshot.lastTxSignature()
-        );
-        statement.setLong(
-                2,
-                snapshot.slot()
-        );
-        statement.setNull(
-                3,
-                Types.BIGINT
-        );
-        statement.setString(
-                4,
-                snapshot.pdaAddress()
-        );
-        statement.setString(
-                5,
-                snapshot.login()
-        );
-        statement.setInt(
-                6,
-                snapshot.recordNumber()
-        );
-        statement.setString(
-                7,
-                snapshot.recoveryKey()
-        );
-        statement.setString(
-                8,
-                snapshot.rootKey()
-        );
-        statement.setString(
-                9,
-                snapshot.clientKey()
-        );
-        statement.setString(
-                10,
-                snapshot.blockchainName()
-        );
-        statement.setString(
-                11,
-                snapshot.blockchainKey()
-        );
-        statement.setLong(
-                12,
-                snapshot.paidLimitBytes()
-        );
-        statement.setLong(
-                13,
-                snapshot.usedBytes()
-        );
-        statement.setInt(
-                14,
-                snapshot.lastBlockNumber()
-        );
-        statement.setString(
-                15,
-                snapshot.lastBlockHash()
-        );
-        statement.setString(
-                16,
-                snapshot.lastBlockSignature()
-        );
-        statement.setString(
-                17,
-                snapshot.arweaveTxId()
-        );
-        statement.setBoolean(
-                18,
-                snapshot.isServer()
-        );
-        statement.setInt(
-                19,
-                snapshot.addressFormatType()
-        );
-        statement.setInt(
-                20,
-                snapshot.addressFormatVersion()
-        );
-        statement.setString(
-                21,
-                snapshot.serverAddress()
-        );
-        statement.setString(
-                22,
-                writeJson(
-                        snapshot.syncServers()
-                )
-        );
-        statement.setString(
-                23,
-                writeJson(
-                        snapshot.accessServers()
-                )
-        );
-        statement.setInt(
-                24,
-                snapshot.sessionsMode()
-        );
-        statement.setString(
-                25,
-                writeJson(
-                        snapshot.sessions()
-                )
-        );
-        statement.setInt(
-                26,
-                snapshot.trustedCount()
-        );
-        statement.setLong(
-                27,
-                snapshot.createdAtMs()
-        );
-        statement.setLong(
-                28,
-                snapshot.updatedAtMs()
-        );
-        statement.setString(
-                29,
-                snapshot.prevRecordHash()
-        );
-        statement.setString(
-                30,
-                snapshot.recordSignature()
-        );
-        statement.setString(
-                31,
-                snapshot.rawDataBase64()
-        );
-        statement.setLong(
-                32,
-                nowMs
-        );
+        int i = 1;
+        statement.setString(i++, snapshot.lastTxSignature());
+        statement.setLong(i++, snapshot.slot());
+        statement.setNull(i++, Types.BIGINT);
+        statement.setString(i++, snapshot.pdaAddress());
+        statement.setString(i++, snapshot.login());
+        statement.setInt(i++, snapshot.recordNumber());
+        statement.setString(i++, snapshot.recoveryKey());
+        statement.setString(i++, snapshot.rootKey());
+        statement.setString(i++, snapshot.clientKey());
+        statement.setString(i++, snapshot.blockchainName());
+        statement.setString(i++, snapshot.blockchainKey());
+        statement.setLong(i++, snapshot.paidLimitBytes());
+        statement.setLong(i++, snapshot.usedBytes());
+        statement.setInt(i++, snapshot.lastBlockNumber());
+        statement.setString(i++, snapshot.lastBlockHash());
+        statement.setString(i++, snapshot.lastBlockSignature());
+        statement.setString(i++, snapshot.arweaveTxId());
+        statement.setString(i++, snapshot.archiveHeadTxId());
+        statement.setString(i++, snapshot.archiveHeadHash());
+        statement.setBoolean(i++, snapshot.isServer());
+        statement.setInt(i++, snapshot.addressFormatType());
+        statement.setInt(i++, snapshot.addressFormatVersion());
+        statement.setString(i++, snapshot.serverAddress());
+        statement.setString(i++, writeJson(snapshot.syncServers()));
+        statement.setString(i++, writeJson(snapshot.accessServers()));
+        statement.setInt(i++, snapshot.sessionsMode());
+        statement.setString(i++, writeJson(snapshot.sessions()));
+        statement.setInt(i++, snapshot.trustedCount());
+        statement.setLong(i++, snapshot.createdAtMs());
+        statement.setLong(i++, snapshot.updatedAtMs());
+        statement.setString(i++, snapshot.prevRecordHash());
+        statement.setString(i++, snapshot.recordSignature());
+        statement.setString(i++, snapshot.rawDataBase64());
+        statement.setLong(i, nowMs);
     }
 
     private void bindCurrentSnapshot(
@@ -678,40 +582,42 @@ public final class PostgresStorageRepository
             ShineUsersCodec.UserPdaSnapshot snapshot,
             long nowMs
     ) throws Exception {
-
-        statement.setString(1, snapshot.pdaAddress());
-        statement.setString(2, snapshot.login());
-        statement.setString(3, normalizeLogin(snapshot.login()));
-        statement.setInt(4, snapshot.recordNumber());
-        statement.setLong(5, snapshot.slot());
-        statement.setString(6, snapshot.lastTxSignature());
-        statement.setString(7, snapshot.recoveryKey());
-        statement.setString(8, snapshot.rootKey());
-        statement.setString(9, snapshot.clientKey());
-        statement.setString(10, snapshot.blockchainName());
-        statement.setString(11, snapshot.blockchainKey());
-        statement.setLong(12, snapshot.paidLimitBytes());
-        statement.setLong(13, snapshot.usedBytes());
-        statement.setInt(14, snapshot.lastBlockNumber());
-        statement.setString(15, snapshot.lastBlockHash());
-        statement.setString(16, snapshot.lastBlockSignature());
-        statement.setString(17, snapshot.arweaveTxId());
-        statement.setBoolean(18, snapshot.isServer());
-        statement.setInt(19, snapshot.addressFormatType());
-        statement.setInt(20, snapshot.addressFormatVersion());
-        statement.setString(21, snapshot.serverAddress());
-        statement.setString(22, writeJson(snapshot.syncServers()));
-        statement.setString(23, writeJson(snapshot.accessServers()));
-        statement.setInt(24, snapshot.sessionsMode());
-        statement.setString(25, writeJson(snapshot.sessions()));
-        statement.setInt(26, snapshot.trustedCount());
-        statement.setLong(27, snapshot.createdAtMs());
-        statement.setLong(28, snapshot.updatedAtMs());
-        statement.setString(29, snapshot.prevRecordHash());
-        statement.setString(30, snapshot.recordSignature());
-        statement.setString(31, snapshot.rawDataBase64());
-        statement.setLong(32, nowMs);
-        statement.setLong(33, nowMs);
+        int i=1;
+        statement.setString(i++, snapshot.pdaAddress());
+        statement.setString(i++, snapshot.login());
+        statement.setString(i++, normalizeLogin(snapshot.login()));
+        statement.setInt(i++, snapshot.recordNumber());
+        statement.setLong(i++, snapshot.slot());
+        statement.setString(i++, snapshot.lastTxSignature());
+        statement.setString(i++, snapshot.recoveryKey());
+        statement.setString(i++, snapshot.rootKey());
+        statement.setString(i++, snapshot.clientKey());
+        statement.setString(i++, snapshot.blockchainName());
+        statement.setString(i++, snapshot.blockchainKey());
+        statement.setLong(i++, snapshot.paidLimitBytes());
+        statement.setLong(i++, snapshot.usedBytes());
+        statement.setInt(i++, snapshot.lastBlockNumber());
+        statement.setString(i++, snapshot.lastBlockHash());
+        statement.setString(i++, snapshot.lastBlockSignature());
+        statement.setString(i++, snapshot.arweaveTxId());
+        statement.setString(i++, snapshot.archiveHeadTxId());
+        statement.setString(i++, snapshot.archiveHeadHash());
+        statement.setBoolean(i++, snapshot.isServer());
+        statement.setInt(i++, snapshot.addressFormatType());
+        statement.setInt(i++, snapshot.addressFormatVersion());
+        statement.setString(i++, snapshot.serverAddress());
+        statement.setString(i++, writeJson(snapshot.syncServers()));
+        statement.setString(i++, writeJson(snapshot.accessServers()));
+        statement.setInt(i++, snapshot.sessionsMode());
+        statement.setString(i++, writeJson(snapshot.sessions()));
+        statement.setInt(i++, snapshot.trustedCount());
+        statement.setLong(i++, snapshot.createdAtMs());
+        statement.setLong(i++, snapshot.updatedAtMs());
+        statement.setString(i++, snapshot.prevRecordHash());
+        statement.setString(i++, snapshot.recordSignature());
+        statement.setString(i++, snapshot.rawDataBase64());
+        statement.setLong(i++, nowMs);
+        statement.setLong(i, nowMs);
     }
 
     private String normalizeLogin(String login) {
@@ -763,6 +669,8 @@ public final class PostgresStorageRepository
                 resultSet.getString("last_block_hash"),
                 resultSet.getString("last_block_signature"),
                 resultSet.getString("arweave_tx_id"),
+                resultSet.getString("archive_head_tx_id"),
+                resultSet.getString("archive_head_hash"),
                 resultSet.getBoolean("is_server"),
                 resultSet.getInt("address_format_type"),
                 resultSet.getInt("address_format_version"),
@@ -933,6 +841,8 @@ public final class PostgresStorageRepository
                             "last_block_hash TEXT NOT NULL, " +
                             "last_block_signature TEXT NOT NULL, " +
                             "arweave_tx_id TEXT NOT NULL, " +
+                            "archive_head_tx_id TEXT NOT NULL DEFAULT '', " +
+                            "archive_head_hash TEXT NOT NULL DEFAULT '', " +
                             "is_server BOOLEAN NOT NULL, " +
                             "address_format_type INTEGER NOT NULL, " +
                             "address_format_version INTEGER NOT NULL, " +
@@ -962,6 +872,9 @@ public final class PostgresStorageRepository
                             "   OR normalized_login <> LOWER(BTRIM(login))"
             );
 
+            statement.executeUpdate("ALTER TABLE solana_user_pda_current ADD COLUMN IF NOT EXISTS archive_head_tx_id TEXT NOT NULL DEFAULT ''");
+            statement.executeUpdate("ALTER TABLE solana_user_pda_current ADD COLUMN IF NOT EXISTS archive_head_hash TEXT NOT NULL DEFAULT ''");
+
             statement.executeUpdate(
                     "CREATE INDEX IF NOT EXISTS idx_user_pda_current_slot " +
                             "ON solana_user_pda_current(slot)"
@@ -995,6 +908,8 @@ public final class PostgresStorageRepository
                             "last_block_hash TEXT NOT NULL, " +
                             "last_block_signature TEXT NOT NULL, " +
                             "arweave_tx_id TEXT NOT NULL, " +
+                            "archive_head_tx_id TEXT NOT NULL DEFAULT '', " +
+                            "archive_head_hash TEXT NOT NULL DEFAULT '', " +
                             "is_server BOOLEAN NOT NULL, " +
                             "address_format_type INTEGER NOT NULL, " +
                             "address_format_version INTEGER NOT NULL, " +
@@ -1014,6 +929,9 @@ public final class PostgresStorageRepository
                             ")"
             );
 
+            statement.executeUpdate("ALTER TABLE solana_user_pda_history ADD COLUMN IF NOT EXISTS archive_head_tx_id TEXT NOT NULL DEFAULT ''");
+            statement.executeUpdate("ALTER TABLE solana_user_pda_history ADD COLUMN IF NOT EXISTS archive_head_hash TEXT NOT NULL DEFAULT ''");
+
             statement.executeUpdate(
                     "CREATE INDEX IF NOT EXISTS idx_user_pda_history_login " +
                             "ON solana_user_pda_history(login)"

SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/util/SolanaPdaUtil.java

@@ -87,7 +87,7 @@ public final class SolanaPdaUtil {
             return false;
         }
 
-        return Ed25519.validatePublicKeyFull(
+        return Ed25519.validatePublicKeyPartial(
                 publicKey,
                 0
         );

SHiNE-server/shine-server-solana-users-sync/src/test/java/sync/util/SolanaPdaUtilTest.java

@@ -0,0 +1,27 @@
+package sync.util;
+
+import org.junit.jupiter.api.Test;
+
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class SolanaPdaUtilTest {
+
+    @Test
+    void findProgramAddressMatchesSolanaRuntimeForUserLoginSeed() {
+        String pda = SolanaPdaUtil.findProgramAddress(
+                List.of(
+                        "user_login=".getBytes(StandardCharsets.UTF_8),
+                        "server_t2".getBytes(StandardCharsets.UTF_8)
+                ),
+                "SHiNEPr1APdAgNBteUyBXcNovaHctpSjUu8oH2ZJdN6"
+        );
+
+        assertEquals(
+                "EJCW7cPXgEMvQAzmhJMZ7pxQxxxFbQYZoJNhcfJpWnz8",
+                pda
+        );
+    }
+}

SHiNE-server/src/main/java/server/files/DmFileApiConfigurator.java

@@ -0,0 +1,14 @@
+package server.files;
+
+import org.eclipse.jetty.servlet.ServletContextHandler;
+import org.eclipse.jetty.servlet.ServletHolder;
+
+/** Регистрирует HTTP API content-addressed хранилища DM-файлов. */
+public final class DmFileApiConfigurator {
+
+    private DmFileApiConfigurator() {}
+
+    public static void register(ServletContextHandler context) {
+        context.addServlet(new ServletHolder(new DmFileServlet()), "/dm-files/*");
+    }
+}

SHiNE-server/src/main/java/server/files/DmFileServlet.java

@@ -0,0 +1,414 @@
+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.math.BigInteger;
+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.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.sql.SQLException;
+import java.util.Objects;
+import java.util.regex.Pattern;
+
+/**
+ * HTTP-хранилище зашифрованных файлов из личных сообщений.
+ *
+ * Сервер намеренно ничего не знает об исходном имени, MIME и ключе AES-GCM:
+ * он получает только ciphertext и хранит его под content-addressed именем
+ * Base58(SHA-256(ciphertext)). Ключ файла передаётся внутри E2EE DM.
+ */
+public final class DmFileServlet extends HttpServlet {
+
+    private static final ObjectMapper MAPPER = new ObjectMapper();
+    private static final String BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    private static final Pattern FILE_ID_PATTERN = Pattern.compile("^[1-9A-HJ-NP-Za-km-z]{32,44}$");
+
+    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 = 50L * 1024L * 1024L + 16L;
+    private static final long MAX_AUTH_SKEW_MS = 60_000L;
+
+    private final boolean enabled;
+    private final Path storageDir;
+    private final long maxBytes;
+
+    public DmFileServlet() {
+        AppConfig config = AppConfig.getInstance();
+        this.enabled = readBoolean(config, "dm.files.enabled", true);
+        this.storageDir = Path.of(readString(config, "dm.files.storageDir", "data/dm-files"))
+                .toAbsolutePath()
+                .normalize();
+        this.maxBytes = Math.max(16L, readLong(config, "dm.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", "Некорректный идентификатор файла");
+            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", "Некорректный идентификатор файла");
+            return;
+        }
+
+        // Content-addressed объект неизменяем. Нельзя доверять одному только имени файла:
+        // перед ответом «уже есть» повторно проверяем реальный SHA-256 сохранённых байтов.
+        // Если файл на диске повреждён/подменён, удаляем его и принимаем корректную загрузку заново.
+        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", "Файл с таким hash уже существует с другим размером");
+                    return;
+                }
+                writeUploadOk(resp, fileId, auth.declaredLength, true);
+                return;
+            }
+            Files.deleteIfExists(target);
+        }
+
+        Path temp = Files.createTempFile(storageDir, ".dm-upload-", ".tmp");
+        boolean keepTemp = 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 = toBase58(digest.digest());
+            if (!Objects.equals(fileId, actualId)) {
+                writeError(resp, HttpServletResponse.SC_BAD_REQUEST, "HASH_MISMATCH", "SHA-256 загруженного ciphertext не совпал с адресом файла");
+                return;
+            }
+
+            boolean alreadyExists = false;
+            try {
+                try {
+                    Files.move(temp, target, StandardCopyOption.ATOMIC_MOVE);
+                } catch (AtomicMoveNotSupportedException ignored) {
+                    Files.move(temp, target);
+                }
+                keepTemp = true; // temp уже перемещён, удалять нечего
+            } catch (FileAlreadyExistsException race) {
+                StoredObjectCheck stored = verifyStoredObject(target, fileId);
+                if (stored.valid() && stored.size() == actualLength) {
+                    alreadyExists = true;
+                } else {
+                    // Даже в редкой гонке не подтверждаем объект, пока его реальные байты не прошли hash-проверку.
+                    Files.deleteIfExists(target);
+                    try {
+                        Files.move(temp, target, StandardCopyOption.ATOMIC_MOVE);
+                    } catch (AtomicMoveNotSupportedException ignored) {
+                        Files.move(temp, target);
+                    }
+                    keepTemp = true;
+                }
+            }
+
+            writeUploadOk(resp, fileId, actualLength, alreadyExists);
+        } finally {
+            if (!keepTemp) {
+                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()) {
+            // Повреждённый content-addressed объект нельзя подтверждать через HEAD и нельзя отдавать через GET.
+            Files.deleteIfExists(target);
+            writeError(resp, HttpServletResponse.SC_NOT_FOUND, "FILE_NOT_FOUND", "Файл не найден");
+            return;
+        }
+
+        long size = stored.size();
+        resp.setStatus(HttpServletResponse.SC_OK);
+        resp.setContentType("application/octet-stream");
+        resp.setHeader("Content-Length", Long.toString(size));
+        resp.setHeader("ETag", "\"" + fileId + "\"");
+        resp.setHeader("Cache-Control", "no-store");
+        resp.setHeader("X-Content-Type-Options", "nosniff");
+        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 actualFileId = toBase58(digest.digest());
+        return new StoredObjectCheck(Objects.equals(expectedFileId, actualFileId), size);
+    }
+
+    private record StoredObjectCheck(boolean valid, long 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 < 16L) {
+            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 encryptedSize, long timeMs) {
+        return "DM_FILE_UPLOAD_V1:" + sessionId + ':' + fileId + ':' + encryptedSize + ':' + 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 MessageDigest sha256Digest() throws IOException {
+        try {
+            return MessageDigest.getInstance("SHA-256");
+        } catch (NoSuchAlgorithmException impossible) {
+            throw new IOException("SHA-256 недоступен", impossible);
+        }
+    }
+
+    static String toBase58(byte[] bytes) {
+        if (bytes == null || bytes.length == 0) return "";
+        BigInteger value = new BigInteger(1, bytes);
+        StringBuilder result = new StringBuilder();
+        BigInteger base = BigInteger.valueOf(58L);
+        while (value.signum() > 0) {
+            BigInteger[] divRem = value.divideAndRemainder(base);
+            result.append(BASE58_ALPHABET.charAt(divRem[1].intValue()));
+            value = divRem[0];
+        }
+        for (byte b : bytes) {
+            if (b != 0) break;
+            result.append('1');
+        }
+        return result.reverse().toString();
+    }
+
+    private static boolean readBoolean(AppConfig config, String key, boolean fallback) {
+        String value = config.getParam(key);
+        if (value == null || value.isBlank()) return fallback;
+        return 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("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 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;
+        }
+    }
+}

SHiNE-server/src/main/java/server/sync/BlockchainResyncRecoveryOnStartup.java

@@ -1,150 +0,0 @@
-package server.sync;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import shine.db.entities.SyncServerEntry;
-import utils.files.FileStoreUtil;
-
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.DirectoryStream;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.stream.Collectors;
-
-/**
- * Startup-recovery для цепочек, которые были помечены как resync-pending.
- *
- * Правило простое:
- *  - marker-file означает, что chain должен быть пересобран заново;
- *  - мы не пытаемся продолжать с середины;
- *  - если recovery не завершён, обычная работа сервера не стартует.
- */
-public final class BlockchainResyncRecoveryOnStartup {
-
-    private static final Logger log = LoggerFactory.getLogger(BlockchainResyncRecoveryOnStartup.class);
-    private static final RemoteBlockchainSyncClient REMOTE = new RemoteBlockchainSyncClient();
-
-    private BlockchainResyncRecoveryOnStartup() {}
-
-    public static void runRecoveryOrThrow() {
-        Path dataDir = Paths.get(FileStoreUtil.DATA_DIR_NAME);
-        ensureDirExists(dataDir);
-
-        List<Path> markers = listMarkerFiles(dataDir);
-        if (markers.isEmpty()) {
-            log.info("🟢 BlockchainResyncRecovery: resync marker-файлы не найдены.");
-            return;
-        }
-
-        log.warn("🟡 BlockchainResyncRecovery: найдено marker-файлов: {}", markers.size());
-        for (Path marker : markers) {
-            recoverSingleMarkerOrThrow(marker);
-        }
-        log.info("✅ BlockchainResyncRecovery: все marker-файлы обработаны.");
-    }
-
-    private static void recoverSingleMarkerOrThrow(Path markerPath) {
-        String fileName = markerPath.getFileName().toString();
-        String blockchainName = extractBlockchainName(fileName);
-        if (blockchainName == null || blockchainName.isBlank()) {
-            throw new IllegalStateException("Bad resync marker name: " + fileName);
-        }
-
-        Map<String, String> meta = parseMarker(markerPath);
-        String partnerLogin = normalize(meta.get("partnerLogin"));
-        String partnerAddress = normalize(meta.get("partnerAddress"));
-        if (partnerAddress == null) {
-            throw new IllegalStateException("Resync marker has no partnerAddress for blockchainName=" + blockchainName);
-        }
-
-        log.warn("🔁 BlockchainResyncRecovery: processing marker blockchainName={} partnerLogin={} partnerAddress={}",
-                blockchainName, partnerLogin, partnerAddress);
-
-        try {
-            List<RemoteBlockchainSyncClient.RemoteBlockchainHead> heads =
-                    REMOTE.listBlockchainHeads(partnerLogin, partnerAddress);
-            RemoteBlockchainSyncClient.RemoteBlockchainHead remoteHead = heads.stream()
-                    .filter(h -> h != null && blockchainName.equals(h.blockchainName()))
-                    .findFirst()
-                    .orElseThrow(() -> new IllegalStateException(
-                            "Partner does not expose blockchainName=" + blockchainName + " address=" + partnerAddress));
-
-            SyncServerEntry partner = new SyncServerEntry(
-                    partnerLogin == null ? "" : partnerLogin,
-                    partnerAddress,
-                    System.currentTimeMillis()
-            );
-
-            PeriodicBlockchainSyncService.resyncFromScratch(partner, remoteHead);
-        } catch (Exception e) {
-            throw new IllegalStateException(
-                    "Не удалось восстановить resync-помеченную цепочку blockchainName=" + blockchainName,
-                    e
-            );
-        }
-    }
-
-    private static List<Path> listMarkerFiles(Path dataDir) {
-        try (DirectoryStream<Path> ds = Files.newDirectoryStream(dataDir, "*" + FileStoreUtil.BLOCKCHAIN_RESYNC_MARKER_EXTENSION)) {
-            return stream(ds).toList();
-        } catch (IOException e) {
-            throw new IllegalStateException("Cannot list resync markers in: " + dataDir, e);
-        }
-    }
-
-    private static java.util.stream.Stream<Path> stream(DirectoryStream<Path> ds) {
-        return java.util.stream.StreamSupport.stream(ds.spliterator(), false)
-                .filter(Files::isRegularFile);
-    }
-
-    private static Map<String, String> parseMarker(Path path) {
-        try {
-            List<String> lines = Files.readAllLines(path, StandardCharsets.UTF_8);
-            Map<String, String> result = new HashMap<>();
-            for (String line : lines) {
-                if (line == null) continue;
-                String s = line.trim();
-                if (s.isEmpty() || s.startsWith("#")) continue;
-                int idx = s.indexOf('=');
-                if (idx <= 0) continue;
-                String key = s.substring(0, idx).trim();
-                String value = s.substring(idx + 1).trim();
-                result.put(key, value);
-            }
-            return result;
-        } catch (IOException e) {
-            throw new IllegalStateException("Cannot read resync marker: " + path, e);
-        }
-    }
-
-    private static void ensureDirExists(Path dir) {
-        try {
-            if (!Files.exists(dir)) {
-                Files.createDirectories(dir);
-            }
-        } catch (IOException e) {
-            throw new IllegalStateException("Cannot create data dir: " + dir, e);
-        }
-    }
-
-    private static String extractBlockchainName(String fileName) {
-        if (fileName == null) return null;
-        String s = fileName.trim();
-        if (!s.endsWith(FileStoreUtil.BLOCKCHAIN_RESYNC_MARKER_EXTENSION)) {
-            return null;
-        }
-        return s.substring(0, s.length() - FileStoreUtil.BLOCKCHAIN_RESYNC_MARKER_EXTENSION.length());
-    }
-
-    private static String normalize(String value) {
-        if (value == null) return null;
-        String s = value.trim();
-        return s.isEmpty() ? null : s.toLowerCase(Locale.ROOT);
-    }
-}

SHiNE-server/src/main/java/server/sync/PeriodicBlockchainSyncService.java

@@ -15,7 +15,6 @@ import shine.db.entities.BlockchainStateEntry;
 import shine.db.entities.SolanaUserPdaCurrentEntry;
 import shine.db.entities.SyncServerEntry;
 import server.sync.BlockchainResyncGuard;
-import utils.files.FileStoreUtil;
 import utils.blockchain.BlockchainNameUtil;
 
 import java.util.concurrent.locks.ReentrantLock;
@@ -52,7 +51,6 @@ public final class PeriodicBlockchainSyncService {
     private static final BlockchainStateDAO STATE_DAO = BlockchainStateDAO.getInstance();
     private static final SyncServersDAO SYNC_SERVERS_DAO = SyncServersDAO.getInstance();
     private static final BlockchainResyncCleanupDAO RESYNC_CLEANUP_DAO = BlockchainResyncCleanupDAO.getInstance();
-    private static final FileStoreUtil FILE_STORE = FileStoreUtil.getInstance();
     private static final SolanaUserPdaCurrentDAO SOLANA_USER_PDA_CURRENT_DAO = SolanaUserPdaCurrentDAO.getInstance();
 
     private PeriodicBlockchainSyncService() {}
@@ -214,26 +212,6 @@ public final class PeriodicBlockchainSyncService {
             return;
         }
 
-        String markerContent = """
-            blockchainName=%s
-            partnerLogin=%s
-            partnerAddress=%s
-            remoteLastBlockNumber=%d
-            remoteLastBlockHash=%s
-            remoteFileSizeBytes=%d
-            startedAtMs=%d
-            """.formatted(
-                blockchainName,
-                partnerLogin == null ? "" : partnerLogin,
-                partner.getServerAddress() == null ? "" : partner.getServerAddress(),
-                remoteHead.lastBlockNumber(),
-                remoteHead.lastBlockHash(),
-                remoteHead.fileSizeBytes(),
-                System.currentTimeMillis()
-        );
-
-        FILE_STORE.writeBlockchainResyncMarker(blockchainName, markerContent);
-
         ReentrantLock chainLock = BlockchainLocks.lockFor(blockchainName);
         chainLock.lock();
         boolean success = false;
@@ -248,9 +226,6 @@ public final class PeriodicBlockchainSyncService {
                     cleanup.deletedBlocksRows(),
                     cleanup.deletedBlockchainStateRows());
 
-            FILE_STORE.deleteBlockchainFileIfExists(blockchainName);
-            FILE_STORE.deleteBlockchainTmpFileIfExists(blockchainName);
-
             if (!ensureLocalChainExists(partner, blockchainName)) {
                 throw new IllegalStateException("failed to recreate local chain state for " + blockchainName);
             }
@@ -260,7 +235,6 @@ public final class PeriodicBlockchainSyncService {
                 throw new IllegalStateException("failed to replay remote chain for " + blockchainName);
             }
 
-            FILE_STORE.deleteBlockchainResyncMarkerIfExists(blockchainName);
             success = true;
             log.info("Blockchain resync completed: partner={} blockchainName={} blocks=0..{}",
                     partnerLogin, blockchainName, remoteHead.lastBlockNumber());

SHiNE-server/src/main/java/server/sync/SolanaUsersSyncStartupService.java

@@ -58,7 +58,15 @@ public final class SolanaUsersSyncStartupService {
         );
 
         service.start();
-        service.awaitReady();
+        try {
+            service.awaitReady();
+        } catch (Exception exception) {
+            log.warn(
+                    "Solana users sync is not ready yet; continuing server startup and leaving sync service running",
+                    exception
+            );
+            return;
+        }
 
         log.info(
                 "Solana users sync is READY. Server startup may continue."

SHiNE-server/src/main/java/server/ws/BlockchainTmpRecoveryOnStartup.java

@@ -1,348 +0,0 @@
-package server.ws;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import shine.db.dao.BlocksDAO;
-import shine.db.dao.BlockchainStateDAO;
-import shine.db.entities.BlockEntry;
-import shine.db.entities.BlockchainStateEntry;
-import utils.files.FileStoreUtil;
-import shine.log.BlockchainAdminNotifier;
-
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.*;
-import java.sql.SQLException;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.HexFormat;
-
-/**
- * ===============================================================
- * BlockchainTmpRecoveryOnStartup — восстановление консистентности
- * файлов обычного AddBlock при старте сервера.
- *
- * Новая модель обычной записи:
- *  1) собирается <name>.tmp_bch как полный кандидат на замену main;
- *  2) пишется sidecar <name>.write_check (blockNumber/blockHash);
- *  3) создаётся пустой marker <name>.write_pending;
- *  4) выполняется SQL-транзакция;
- *  5) после commit tmp атомарно ставится на место main;
- *  6) marker и sidecar удаляются.
- *
- * На старте:
- *  - если найден marker, recovery добивает запись или чистит мусор;
- *  - если marker нет, а tmp/check остались, это мусор и он удаляется;
- *  - legacy tmp-файлы без marker тоже считаются мусором.
- *
- * Принцип:
- *  - marker означает, что операция вошла в опасную фазу и должна быть доведена до конца или откатана;
- *  - sidecar нужен только как маленькое описание текущей операции (blockNumber/blockHash);
- *  - если marker отсутствует, временные файлы не считаются валидными.
- * ===============================================================
- */
-public final class BlockchainTmpRecoveryOnStartup {
-
-    private static final Logger log = LoggerFactory.getLogger(BlockchainTmpRecoveryOnStartup.class);
-    private static final HexFormat HEX = HexFormat.of();
-
-    private BlockchainTmpRecoveryOnStartup() {}
-
-    public static void runRecoveryOrThrow() {
-        FileStoreUtil fs = FileStoreUtil.getInstance();
-        BlockchainStateDAO stateDAO = BlockchainStateDAO.getInstance();
-        BlocksDAO blocksDAO = BlocksDAO.getInstance();
-
-        Path dataDir = Paths.get(FileStoreUtil.DATA_DIR_NAME);
-        ensureDirExists(dataDir);
-
-        List<Path> markers = listFilesWithSuffix(dataDir, FileStoreUtil.BLOCKCHAIN_WRITE_PENDING_MARKER_EXTENSION);
-        if (!markers.isEmpty()) {
-            log.warn("🟡 BlockchainTmpRecovery: найдено marker-файлов обычного AddBlock: {}", markers.size());
-        } else {
-            log.info("🟢 BlockchainTmpRecovery: marker-файлов обычного AddBlock не найдено.");
-        }
-
-        for (Path marker : markers) {
-            recoverSingleWriteMarkerOrThrow(marker, fs, stateDAO, blocksDAO);
-        }
-
-        cleanupOrphanTempArtifacts(dataDir, fs);
-        log.info("✅ BlockchainTmpRecovery: обработка временных файлов AddBlock завершена.");
-    }
-
-    private static void recoverSingleWriteMarkerOrThrow(Path markerPath,
-                                                        FileStoreUtil fs,
-                                                        BlockchainStateDAO stateDAO,
-                                                        BlocksDAO blocksDAO) {
-        String markerFileName = markerPath.getFileName().toString();
-        String blockchainName = extractBlockchainName(markerFileName, FileStoreUtil.BLOCKCHAIN_WRITE_PENDING_MARKER_EXTENSION);
-        if (blockchainName == null || blockchainName.isBlank()) {
-            BlockchainAdminNotifier.critical(
-                    "НАЙДЕН write_pending marker С НЕОЖИДАННЫМ ИМЕНЕМ: " + markerFileName,
-                    null
-            );
-            throw new IllegalStateException("Bad write marker name: " + markerFileName);
-        }
-
-        Path tmpPath = fs.resolveBlockchainTmpPath(blockchainName);
-        Path checkPath = fs.resolveBlockchainWriteCheckPath(blockchainName);
-        Path mainPath = fs.resolveBlockchainPath(blockchainName);
-
-        Map<String, String> meta = parseKeyValueFile(checkPath);
-        Integer expectedBlockNumber = parseInt(meta.get("blockNumber"));
-        String expectedBlockHashHex = normalizeHex(meta.get("blockHash"));
-
-        try {
-            BlockchainStateEntry st = stateDAO.getByBlockchainName(blockchainName);
-            boolean mainExists = Files.exists(mainPath);
-            boolean tmpExists = Files.exists(tmpPath);
-            long mainSize = mainExists ? safeSize(mainPath) : -1L;
-            long tmpSize = tmpExists ? safeSize(tmpPath) : -1L;
-
-            if (st == null) {
-                log.warn("🟠 BlockchainTmpRecovery: marker есть, но blockchain_state отсутствует. blockchainName={}. Удаляем временные файлы.",
-                        blockchainName);
-                cleanupWriteArtifacts(markerPath, checkPath, tmpPath);
-                return;
-            }
-
-            long stateSize = st.getFileSizeBytes();
-
-            if (expectedBlockNumber == null || expectedBlockHashHex == null) {
-                log.warn("🟠 BlockchainTmpRecovery: write_check повреждён или пуст. blockchainName={}. Пробуем recovery по размерам.",
-                        blockchainName);
-
-                if (mainExists && mainSize == stateSize) {
-                    cleanupWriteArtifacts(markerPath, checkPath, tmpPath);
-                    return;
-                }
-                if (tmpExists && tmpSize == stateSize) {
-                    fs.atomicReplaceBlockchainFile(blockchainName);
-                    cleanupWriteArtifacts(markerPath, checkPath, tmpPath);
-                    return;
-                }
-                if (tmpExists && mainExists) {
-                    cleanupWriteArtifacts(markerPath, checkPath, tmpPath);
-                    return;
-                }
-                cleanupWriteArtifacts(markerPath, checkPath, tmpPath);
-                return;
-            }
-
-            BlockEntry block = blocksDAO.getByNumber(blockchainName, expectedBlockNumber);
-            if (block == null || block.getBlockHash() == null) {
-                log.warn("🟠 BlockchainTmpRecovery: в blocks нет ожидаемого блока. blockchainName={}, blockNumber={}. Чистим временные файлы.",
-                        blockchainName, expectedBlockNumber);
-                cleanupWriteArtifacts(markerPath, checkPath, tmpPath);
-                return;
-            }
-
-            String actualHashHex = HEX.formatHex(block.getBlockHash());
-            if (!actualHashHex.equalsIgnoreCase(expectedBlockHashHex)) {
-                log.warn("🟠 BlockchainTmpRecovery: hash в write_check не совпал с DB. blockchainName={}, expected={}, actual={}. Чистим временные файлы.",
-                        blockchainName, expectedBlockHashHex, actualHashHex);
-                cleanupWriteArtifacts(markerPath, checkPath, tmpPath);
-                return;
-            }
-
-            // Если main уже совпадает со state — tmp/check/marker лишние.
-            if (mainExists && mainSize == stateSize) {
-                log.info("🟢 BlockchainTmpRecovery: main уже соответствует state. blockchainName={}, stateSize={}, mainSize={}",
-                        blockchainName, stateSize, mainSize);
-                cleanupWriteArtifacts(markerPath, checkPath, tmpPath);
-                return;
-            }
-
-            // Если tmp уже готов и совпадает со state — просто ставим его на место main.
-            if (tmpExists && tmpSize == stateSize) {
-                log.warn("🟡 BlockchainTmpRecovery: tmp соответствует state, восстанавливаем main. blockchainName={}, stateSize={}, tmpSize={}",
-                        blockchainName, stateSize, tmpSize);
-                fs.atomicReplaceBlockchainFile(blockchainName);
-                cleanupWriteArtifacts(markerPath, checkPath, tmpPath);
-                return;
-            }
-
-            // Если tmp нет, но DB уже закоммитила блок — пробуем восстановить tmp из main + block_bytes.
-            if (!tmpExists && mainExists) {
-                long expectedDelta = block.getBlockBytes() == null ? -1L : block.getBlockBytes().length;
-                if (expectedDelta >= 0 && mainSize + expectedDelta == stateSize) {
-                    log.warn("🟡 BlockchainTmpRecovery: tmp отсутствует, но main+DB дают валидный кандидат. blockchainName={}. Восстанавливаем tmp и main.",
-                            blockchainName);
-                    byte[] rebuilt = rebuildTmpFromMainAndBlock(mainPath, block.getBlockBytes());
-                    fs.writeBlockchainTmp(blockchainName, rebuilt);
-                    fs.atomicReplaceBlockchainFile(blockchainName);
-                    cleanupWriteArtifacts(markerPath, checkPath, tmpPath);
-                    return;
-                }
-            }
-
-            // Если tmp есть, но его размер не совпал, пробуем восстановить из main + block_bytes.
-            if (mainExists) {
-                long expectedDelta = block.getBlockBytes() == null ? -1L : block.getBlockBytes().length;
-                if (expectedDelta >= 0 && mainSize + expectedDelta == stateSize) {
-                    log.warn("🟡 BlockchainTmpRecovery: tmp/size не совпали, пересобираем tmp из main+block_bytes. blockchainName={}",
-                            blockchainName);
-                    byte[] rebuilt = rebuildTmpFromMainAndBlock(mainPath, block.getBlockBytes());
-                    fs.writeBlockchainTmp(blockchainName, rebuilt);
-                    fs.atomicReplaceBlockchainFile(blockchainName);
-                    cleanupWriteArtifacts(markerPath, checkPath, tmpPath);
-                    return;
-                }
-            }
-
-            // Если ничего не совпало, это уже подозрительное состояние.
-            BlockchainAdminNotifier.critical(
-                    "НЕСОГЛАСОВАННОСТЬ ОПЕРАЦИИ AddBlock ПРИ СТАРТЕ. blockchainName=" + blockchainName +
-                            ", stateSize=" + stateSize +
-                            ", mainExists=" + mainExists +
-                            ", mainSize=" + mainSize +
-                            ", tmpExists=" + tmpExists +
-                            ", tmpSize=" + tmpSize +
-                            ", expectedBlockNumber=" + expectedBlockNumber +
-                            ", expectedBlockHash=" + expectedBlockHashHex +
-                            ". Требуется ручная проверка.",
-                    null
-            );
-            throw new IllegalStateException("AddBlock recovery mismatch for " + blockchainName);
-        } catch (SQLException e) {
-            BlockchainAdminNotifier.critical(
-                    "ОШИБКА БД ПРИ ВОССТАНОВЛЕНИИ AddBlock marker: blockchainName=" + blockchainName,
-                    e
-            );
-            throw new IllegalStateException("DB error during AddBlock recovery for " + blockchainName, e);
-        }
-    }
-
-    private static void cleanupOrphanTempArtifacts(Path dataDir, FileStoreUtil fs) {
-        List<Path> tmpFiles = listFilesWithSuffix(dataDir, FileStoreUtil.BLOCKCHAIN_TMP_EXTENSION);
-        List<Path> checkFiles = listFilesWithSuffix(dataDir, FileStoreUtil.BLOCKCHAIN_WRITE_CHECK_EXTENSION);
-
-        if (tmpFiles.isEmpty() && checkFiles.isEmpty()) {
-            return;
-        }
-
-        log.warn("🟡 BlockchainTmpRecovery: найдено orphan tmp/check файлов. tmp={}, check={}", tmpFiles.size(), checkFiles.size());
-        for (Path tmp : tmpFiles) {
-            String blockchainName = extractBlockchainName(tmp.getFileName().toString(), FileStoreUtil.BLOCKCHAIN_TMP_EXTENSION);
-            if (blockchainName != null && Files.exists(fs.resolveBlockchainWritePendingMarkerPath(blockchainName))) {
-                continue;
-            }
-            safeDelete(tmp);
-        }
-        for (Path check : checkFiles) {
-            String blockchainName = extractBlockchainName(check.getFileName().toString(), FileStoreUtil.BLOCKCHAIN_WRITE_CHECK_EXTENSION);
-            if (blockchainName != null && Files.exists(fs.resolveBlockchainWritePendingMarkerPath(blockchainName))) {
-                continue;
-            }
-            safeDelete(check);
-        }
-    }
-
-    private static void cleanupWriteArtifacts(Path markerPath, Path checkPath, Path tmpPath) {
-        safeDelete(markerPath);
-        safeDelete(checkPath);
-        safeDelete(tmpPath);
-    }
-
-    private static byte[] rebuildTmpFromMainAndBlock(Path mainPath, byte[] blockBytes) {
-        try {
-            byte[] mainBytes = Files.exists(mainPath) ? Files.readAllBytes(mainPath) : new byte[0];
-            byte[] out = new byte[mainBytes.length + blockBytes.length];
-            System.arraycopy(mainBytes, 0, out, 0, mainBytes.length);
-            System.arraycopy(blockBytes, 0, out, mainBytes.length, blockBytes.length);
-            return out;
-        } catch (IOException e) {
-            throw new IllegalStateException("Cannot rebuild tmp from main: " + mainPath, e);
-        }
-    }
-
-    private static Map<String, String> parseKeyValueFile(Path path) {
-        Map<String, String> result = new HashMap<>();
-        if (path == null || !Files.exists(path)) {
-            return result;
-        }
-        try {
-            for (String line : Files.readAllLines(path, StandardCharsets.UTF_8)) {
-                if (line == null) continue;
-                String s = line.trim();
-                if (s.isEmpty() || s.startsWith("#")) continue;
-                int idx = s.indexOf('=');
-                if (idx <= 0) continue;
-                String key = s.substring(0, idx).trim();
-                String value = s.substring(idx + 1).trim();
-                result.put(key, value);
-            }
-            return result;
-        } catch (IOException e) {
-            throw new IllegalStateException("Cannot read write_check file: " + path, e);
-        }
-    }
-
-    private static Integer parseInt(String value) {
-        if (value == null || value.isBlank()) return null;
-        try {
-            return Integer.parseInt(value.trim());
-        } catch (Exception e) {
-            return null;
-        }
-    }
-
-    private static String normalizeHex(String value) {
-        if (value == null) return null;
-        String s = value.trim();
-        return s.isEmpty() ? null : s;
-    }
-
-    private static void ensureDirExists(Path dir) {
-        try {
-            if (!Files.exists(dir)) {
-                Files.createDirectories(dir);
-            }
-        } catch (IOException e) {
-            throw new IllegalStateException("Cannot create data dir: " + dir, e);
-        }
-    }
-
-    private static List<Path> listFilesWithSuffix(Path dataDir, String suffix) {
-        List<Path> out = new ArrayList<>();
-        try (DirectoryStream<Path> ds = Files.newDirectoryStream(dataDir, "*" + suffix)) {
-            for (Path p : ds) {
-                if (Files.isRegularFile(p)) {
-                    out.add(p);
-                }
-            }
-        } catch (IOException e) {
-            throw new IllegalStateException("Cannot list files in: " + dataDir + " suffix=" + suffix, e);
-        }
-        return out;
-    }
-
-    private static String extractBlockchainName(String fileName, String suffix) {
-        if (fileName == null) return null;
-        String s = fileName.trim();
-        if (!s.endsWith(suffix)) return null;
-        String base = s.substring(0, s.length() - suffix.length());
-        if (base.isBlank()) return null;
-        if (base.contains("/") || base.contains("\\") || base.contains("..")) return null;
-        return base;
-    }
-
-    private static long safeSize(Path p) {
-        try {
-            return Files.size(p);
-        } catch (IOException e) {
-            throw new IllegalStateException("Cannot read file size: " + p, e);
-        }
-    }
-
-    private static void safeDelete(Path p) {
-        try {
-            Files.deleteIfExists(p);
-        } catch (IOException e) {
-            throw new IllegalStateException("Cannot delete file: " + p, e);
-        }
-    }
-}

SHiNE-server/src/main/java/server/ws/WsServer.java

@@ -5,8 +5,10 @@ import org.eclipse.jetty.servlet.ServletContextHandler;
 import org.eclipse.jetty.websocket.server.config.JettyWebSocketServletContainerInitializer;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import server.archive.ArweaveBlockPublisherScheduler;
+import server.archive.ArweaveBlockSyncScheduler;
 import server.debug.DebugApiConfigurator;
-import server.sync.BlockchainResyncRecoveryOnStartup;
+import server.files.DmFileApiConfigurator;
 import server.sync.PeriodicBlockchainSyncService;
 import server.sync.PeriodicDmDeliveryService;
 import server.sync.SolanaUsersSyncStartupService;
@@ -19,10 +21,7 @@ import java.time.Duration;
 /**
  * WsServer — поднимает Jetty WS на /ws.
  *
- * ВАЖНО:
- *  - перед стартом сервера выполняем recovery tmp-блокчейнов.
- *  - если обнаружена несогласованность, которую сервер сам чинить не может —
- *    recovery бросает исключение и сервер не стартует.
+ * Пользовательские блоки хранятся в PostgreSQL; локальные .bch-файлы больше не используются.
  */
 public final class WsServer {
 
@@ -30,28 +29,6 @@ public final class WsServer {
 
     public static void main(String[] args) throws Exception {
 
-        // ============================================================
-        // 0) Восстановление консистентности blockchain файлов
-        // ============================================================
-        try {
-            BlockchainTmpRecoveryOnStartup.runRecoveryOrThrow();
-        } catch (Exception e) {
-            // Уже должно быть “большое” уведомление через BlockchainAdminNotifier,
-            // но на всякий случай логируем ещё раз.
-            log.error("❌ Сервер НЕ будет запущен: критическая ошибка восстановления blockchain tmp-файлов.", e);
-            throw e; // останавливаем запуск
-        }
-
-        // ============================================================
-        // 0.1) Восстановление цепочек, зависших на full resync
-        // ============================================================
-        try {
-            BlockchainResyncRecoveryOnStartup.runRecoveryOrThrow();
-        } catch (Exception e) {
-            log.error("❌ Сервер НЕ будет запущен: критическая ошибка восстановления blockchain resync-маркеров.", e);
-            throw e;
-        }
-
         // ============================================================
         // 1.0) Синхронизация пользовательских Solana PDA
         // ============================================================
@@ -81,6 +58,10 @@ public final class WsServer {
         // ============================================================
         PeriodicBlockchainSyncService.startOrLog();
 
+        // ANS-104: publish locally-created signed user blocks and discover blocks published by other servers.
+        ArweaveBlockPublisherScheduler.startOrLog();
+        ArweaveBlockSyncScheduler.startOrLog();
+
         // ============================================================
         // 2) Запуск Jetty WS
         // ============================================================
@@ -93,6 +74,9 @@ public final class WsServer {
         // HTTP debug API
         DebugApiConfigurator.register(context);
 
+        // Зашифрованные вложения личных сообщений: PUT/GET /dm-files/{sha256-base58}
+        DmFileApiConfigurator.register(context);
+
         // Инициализация контейнера WebSocket
         JettyWebSocketServletContainerInitializer.configure(context, (servletContext, wsContainer) -> {
             // Таймаут простоя соединения (Jetty 11 синтаксис)
@@ -106,7 +90,7 @@ public final class WsServer {
         log.info("✅ WS сервер запущен на ws://localhost:{}/ws", port);
         ServerConnectionPool.getInstance().startOrLog();
         Runtime.getRuntime().addShutdownHook(new Thread(
-                () -> ServerConnectionPool.getInstance().close(),
+                () -> { ServerConnectionPool.getInstance().close(); ArweaveBlockPublisherScheduler.close(); ArweaveBlockSyncScheduler.close(); },
                 "server-connection-pool-shutdown"));
         PeriodicDmDeliveryService.startOrLog();
         server.join();

SHiNE-server/src/main/resources/application.properties

@@ -53,6 +53,18 @@ server.ui.indexPath=/home/player/SHiNE/shine-UI/index.html
 server.ui.buildHash=
 
 # Web Push (VAPID)
+
+# ================================
+# DM encrypted file storage
+# ================================
+# На диске лежит только AES-GCM ciphertext. Имя файла = Base58(SHA-256(ciphertext)).
+dm.files.enabled=true
+dm.files.storageDir=data/dm-files
+# Лимит одного immutable ciphertext-объекта, НЕ всего файла.
+# DM file v2 режет файл на 1 MiB части, поэтому общий размер файла этим параметром не ограничен.
+# Значение 50 MiB сохранено для совместимости с DM file v1.
+dm.files.maxBytes=52428816
+
 webpush.vapid.public=BOdoWZndZRaNe9kyUFsJ5-xEfFABXNKennAKg15Z7ycAwUIQ7yDV_sIWWYJCwJriN4g9oU-CyJPrn1U6lfxuDbI
 webpush.vapid.private=3hCt7XxTvLzuoxinjT5QcKRQEBnGZHXn8ZilU31RPNE
 webpush.vapid.subject=mailto:admin@shine.local
@@ -115,3 +127,26 @@ test.freeAvatar.limitPerUser=3
 test.freeAvatar.maxBytes=131072
 test.freeAvatar.walletAddress=
 test.freeAvatar.walletJwkPath=
+
+# ============================================================
+# Arweave per-user-block transport (ANS-104)
+# Test namespace: each user DataItem is signed with App=test5590.
+# Channel DataItems additionally contain c=<canonical-channel-slug>.
+# ============================================================
+arweave.blocks.publish.enabled=false
+arweave.blocks.publish.intervalMinutes=15
+arweave.blocks.publish.maxItems=10000
+arweave.blocks.publish.maxBundleBytes=134217728
+arweave.blocks.publish.gateway=https://arweave.net
+arweave.blocks.publish.walletJwkPath=
+arweave.blocks.publish.minConfirmations=0
+arweave.blocks.publish.confirmPollSeconds=30
+arweave.blocks.publish.confirmTimeoutMinutes=180
+
+arweave.blocks.sync.enabled=false
+arweave.blocks.sync.intervalMinutes=15
+arweave.blocks.sync.gateway=https://turbo-gateway.com
+arweave.blocks.sync.pageSize=100
+arweave.blocks.sync.queueBatchSize=10000
+arweave.blocks.sync.startBlockHeight=0
+arweave.blocks.sync.maxRootBundleBytes=268435456

SHiNE-server/src/test/java/test/it/blockchain/AddBlockSender.java

@@ -1,5 +1,6 @@
 package test.it.blockchain;
 
+import blockchain.Ans104DataItem;
 import blockchain.BchBlockEntry;
 import blockchain.body.*;
 import test.it.utils.TestConfig;
@@ -9,20 +10,19 @@ import test.it.utils.log.TestLog;
 import test.it.utils.ws.WsSession;
 
 import java.time.Duration;
+import java.util.ArrayList;
 import java.util.Base64;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 /**
- * AddBlockSender — под новый формат BchBlockEntry (Frame v0):
- *  - blockBytes = preimage + sigMarker(2) + signature64
- *  - preimage начинается с frameCode(2) = 0x0000
- *  - hash32 вычисляется как sha256(preimage)
- *  - signature = Ed25519.sign(hash32)
- *
- * ВАЖНО:
- *  - Линии по ТЗ ведём на стороне сервера/БД (триггеры), а в тестах считаем локально.
+ * AddBlockSender для Frame v1: blockBytesB64 содержит готовый ANS-104 DataItem.
+ * SHiNE hash цепочки остаётся SHA-256(Frame v1 bytes), а пользователь подписывает
+ * ANS-104 deep-hash одним Ed25519 ключом.
  */
 public final class AddBlockSender {
 
@@ -34,6 +34,7 @@ public final class AddBlockSender {
     private final String login;
     private final String blockchainName;
     private final byte[] loginPrivKey;
+    private final Map<Integer, String> channelSlugByRoot = new HashMap<>();
 
     public AddBlockSender(WsSession ws, ChainState state, String login, String blockchainName, byte[] loginPrivKey) {
         this.ws = ws;
@@ -75,22 +76,18 @@ public final class AddBlockSender {
 
         byte[] bodyBytes = body.toBytes();
 
-        // ВАЖНО: preimage должен быть БАЙТ-В-БАЙТ таким же, как в BchBlockEntry
-        byte[] preimage = buildPreimage(prevHash32, blockNumber, tsSec, type, subType, version, bodyBytes);
+        byte[] frame = buildFrame(prevHash32, blockNumber, tsSec, type, subType, version, bodyBytes);
+        byte[] owner32 = utils.crypto.Ed25519Util.derivePublicKey(loginPrivKey);
 
-        byte[] hash32 = blockchain.BchCryptoVerifier.sha256(preimage);
-        byte[] signature64 = utils.crypto.Ed25519Util.sign(hash32, loginPrivKey);
+        List<Ans104DataItem.Tag> tags = new ArrayList<>();
+        tags.add(new Ans104DataItem.Tag("App", "test5590"));
+        String channelSlug = channelSlugFor(body);
+        if (channelSlug != null) tags.add(new Ans104DataItem.Tag("c", channelSlug));
 
-        BchBlockEntry entry = new BchBlockEntry(
-                prevHash32,
-                blockNumber,
-                tsSec,
-                type,
-                subType,
-                version,
-                bodyBytes,
-                signature64
-        );
+        byte[] signingMessage = Ans104DataItem.buildSigningMessage(owner32, tags, frame);
+        byte[] signature64 = utils.crypto.Ed25519Util.sign(signingMessage, loginPrivKey);
+        byte[] rawDataItem = Ans104DataItem.serializeEd25519(signature64, owner32, tags, frame);
+        BchBlockEntry entry = new BchBlockEntry(rawDataItem);
 
         String prevHashHexForReq = (blockNumber == 0) ? ZERO64 : state.lastBlockHashHex();
 
@@ -119,6 +116,9 @@ public final class AddBlockSender {
         assertEquals(localHashHex, serverLastHash, op + ": serverLastBlockHash must match local hash");
 
         state.applyAppendedBlock(blockNumber, entry.getHash32(), isHeader, type, body);
+        if (body instanceof CreateChannelBody ccb) {
+            channelSlugByRoot.put(blockNumber, shine.db.channels.ChannelNameRules.toCanonicalSlug(ccb.channelName));
+        }
 
         if (TestConfig.DEBUG()) TestLog.info(op + ": state updated");
     }
@@ -194,48 +194,47 @@ public final class AddBlockSender {
         throw new IllegalArgumentException("Unknown body class: " + body.getClass());
     }
 
-    // ---------- preimage builder (строго по BchBlockEntry Frame v0) ----------
+    // ---------- Frame v1 + signed channel tag helpers ----------
 
-    private static byte[] buildPreimage(byte[] prevHash32,
-                                        int blockNumber,
-                                        long tsSec,
-                                        short type,
-                                        short subType,
-                                        short version,
-                                        byte[] bodyBytes) {
+    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) {
+            String slug = channelSlugByRoot.get(tb.lineCode);
+            if (slug == null) {
+                throw new IllegalStateException("Unknown channel slug for lineCode=" + tb.lineCode);
+            }
+            return slug;
+        }
+        return null;
+    }
+
+    private static byte[] buildFrame(byte[] prevHash32,
+                                     int blockNumber,
+                                     long tsSec,
+                                     short type,
+                                     short subType,
+                                     short version,
+                                     byte[] bodyBytes) {
 
         if (prevHash32 == null || prevHash32.length != 32) {
             throw new IllegalArgumentException("prevHash32 must be 32 bytes");
         }
 
-        int bodyLen = (bodyBytes == null ? 0 : bodyBytes.length);
-        int blockSize = BchBlockEntry.PREIMAGE_HEADER_SIZE + bodyLen;
-
+        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);
-
-        // [2] frameCode (v0)
-        bb.putShort((short) (BchBlockEntry.FRAME_CODE_V0 & 0xFFFF));
-
-        // [32] prevHash32
+        bb.putShort((short) BchBlockEntry.FRAME_CODE_V1);
         bb.put(prevHash32);
-
-        // [4] blockSize (preimage size)
         bb.putInt(blockSize);
-
-        // [4] blockNumber
         bb.putInt(blockNumber);
-
-        // [8] timestamp
         bb.putLong(tsSec);
-
-        // [2][2][2] type/subType/version
         bb.putShort(type);
         bb.putShort(subType);
         bb.putShort(version);
-
-        // [N] bodyBytes
         if (bodyBytes != null) bb.put(bodyBytes);
-
         return bb.array();
     }
+
 }

VERSION.properties

@@ -1,2 +1,2 @@
-client.version=1.12.2
-server.version=1.10.1
+client.version=1.12.20
+server.version=1.10.8

build.gradle

@@ -84,6 +84,7 @@ dependencies {
     implementation project(':shine-server-net-protocol') // Модуль отвечающий за протокол (классы Net..Request/Response
     implementation project(':shine-server-net-server')   // Хэндлеры для обработки сетевых запросов
     implementation project(':shine-server-solana-users-sync')
+    implementation project(':shine-server-archive')
 
 
 

bundle.sh

@@ -13,7 +13,13 @@ set -Eeuo pipefail
 ROOT="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
 cd "$ROOT"
 
-OUT="${1:-SHiNE-bundle-$(date +%Y%m%d-%H%M%S).zip}"
+DEFAULT_OUT=0
+if [[ $# -gt 0 ]]; then
+  OUT="$1"
+else
+  DEFAULT_OUT=1
+  OUT="SHiNE-bundle-$(date +%Y.%m.%d-%H.%M.%S).zip"
+fi
 case "$OUT" in
   /*) ;;
   *) OUT="$ROOT/$OUT" ;;
@@ -169,7 +175,11 @@ if [[ ! -s "$SAFE_LIST" ]]; then
   exit 3
 fi
 
-rm -f -- "$OUT"
+if (( DEFAULT_OUT == 1 )); then
+  rm -f -- "$ROOT"/SHiNE-bundle-*.zip
+else
+  rm -f -- "$OUT"
+fi
 
 (
   cd "$ROOT"

deploy/SETUP_SERVER_FROM_ZERO.md

@@ -92,6 +92,12 @@ t2.shineup.me {
     reverse_proxy 127.0.0.1:7102
   }
 
+  # Зашифрованные вложения DM. Этот route должен идти в Java, а не в SPA.
+  @dmfiles path /dm-files /dm-files/*
+  handle @dmfiles {
+    reverse_proxy 127.0.0.1:7102
+  }
+
   handle {
     root * /home/player/t2/UI
     try_files {path} /index.html

deploy/backup/scheme/shineup.me/configs/Caddyfile

@@ -10,6 +10,11 @@ shineup.me {
     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
@@ -31,6 +36,11 @@ shineup.me {
     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

deploy/scripts/deploy_server.sh

@@ -9,6 +9,7 @@ TARGET_DOMAIN="${TARGET_DOMAIN:?TARGET_DOMAIN is required, example: shineup.me}"
 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_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}"
@@ -54,7 +55,7 @@ Type=simple
 User=player
 Group=player
 WorkingDirectory=$REMOTE_SERVER_DIR
-ExecStart=/usr/bin/java -Dserver.port=$SERVER_PORT -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} -jar $REMOTE_SERVER_DIR/shine-server.jar
 Restart=always
 RestartSec=3
 
@@ -62,7 +63,11 @@ RestartSec=3
 WantedBy=multi-user.target
 EOF
 
-ssh "$REMOTE_HOST" "mkdir -p '$REMOTE_SERVER_DIR' '$REMOTE_DATA_DIR' '$REMOTE_LOGS_DIR'"
+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
 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"
 

deploy/scripts/test_t1_server.sh

@@ -4,6 +4,7 @@ set -euo pipefail
 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_SERVICE_NAME="shine-t1" \
 SERVER_PORT="7101" \
 bash "$(dirname "$0")/deploy_server.sh"

deploy/scripts/test_t2_server.sh

@@ -4,6 +4,7 @@ set -euo pipefail
 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_SERVICE_NAME="shine-t2" \
 SERVER_PORT="7102" \
 bash "$(dirname "$0")/deploy_server.sh"

deploy/scripts/test_t3_server.sh

@@ -4,6 +4,7 @@ set -euo pipefail
 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_SERVICE_NAME="shine-t3" \
 SERVER_PORT="7103" \
 bash "$(dirname "$0")/deploy_server.sh"

deploy/scripts/test_t4_server.sh

@@ -4,6 +4,7 @@ set -euo pipefail
 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_SERVICE_NAME="shine-t4" \
 SERVER_PORT="7104" \
 bash "$(dirname "$0")/deploy_server.sh"

docs/API/04_Add_Block_to_Blockchain_API.md

@@ -1,310 +1,49 @@
-# API для разработчиков: 04 — Запись и чтение блока блокчейна
+# AddBlock API
 
-Документ описывает **текущий рабочий формат** сетевых вызовов:
+## Назначение
 
-- `AddBlock` — запись любого блока в блокчейн пользователя;
-- `GetBlockchainBlock` — публичное чтение одного конкретного блока по имени цепочки и номеру.
+Добавляет один готовый подписанный пользовательский SHiNE Frame v1 / ANS-104 DataItem в blockchain.
 
-`GetBlockchainBlock` нужен в том числе для межсерверной синхронизации и для открытого чтения публичного блокчейна по одному блоку.
-
-> Важный принцип: на уровне JSON API сейчас есть **один универсальный метод** записи — `AddBlock`.
-> Конкретный смысл записи задаётся типом самого бинарного блока (`type/subType/version` в заголовке блока).
-
-## 1. Что делает `AddBlock`
-
-`AddBlock`:
-- принимает имя блокчейна и base64 бинарного блока;
-- проверяет непрерывность цепочки (`blockNumber`, `prevHash`);
-- проверяет формат и подпись Ed25519;
-- валидирует `body` по правилам типа блока;
-- сохраняет блок и обновляет состояние цепочки.
-
-## 2. JSON формат запроса
-
-`op = "AddBlock"`.
+## Request
 
 ```json
 {
   "op": "AddBlock",
-  "requestId": "req-1001",
+  "requestId": "...",
   "payload": {
-    "blockchainName": "alice-001",
-    "blockNumber": 12,
-    "prevBlockHash": "ab12...ff", 
-    "blockBytesB64": "AAAB..."
+    "blockchainName": "alice-...",
+    "blockNumber": 42,
+    "prevBlockHash": "64 hex chars",
+    "blockBytesB64": "..."
   }
 }
 ```
 
-Поля `payload`:
-- `blockchainName` — обязательно, формат `login-NNN`.
-- `blockNumber` — обязательно (временное legacy-поле для совместимости; должно совпасть с номером внутри бинарного блока).
-- `prevBlockHash` — legacy-поле, сейчас сервер использует `prevHash` из бинарного блока и состояние цепочки.
-- `blockBytesB64` — обязательно: **полный бинарный блок** (`preimage + sigMarker + signature`) в Base64.
+- `blockchainName` — целевая пользовательская chain;
+- `blockNumber` — должен совпадать с номером внутри Frame v1 и быть `serverLast + 1`;
+- `prevBlockHash` — 32-byte SHiNE hash предыдущего Frame в hex; должен совпадать с `prevHash32` внутри Frame и серверной вершиной;
+- `blockBytesB64` — **полный serialized ANS-104 DataItem** в Base64.
 
-## 3. Успешный ответ
+Старый формат `preimage + sigMarker + signature` не поддерживается.
 
-```json
-{
-  "op": "AddBlock",
-  "requestId": "req-1001",
-  "status": 200,
-  "ok": true,
-  "payload": {
-    "reasonCode": null,
-    "serverLastGlobalNumber": 12,
-    "serverLastGlobalHash": "9f0e...a1"
-  }
-}
-```
+## Требования к DataItem
 
-## 4. Ошибка (единый формат)
+- generic Ed25519 signature type `2`;
+- Ed25519 signature 64 bytes;
+- owner 32 bytes и равен текущему blockchain public key;
+- обязательный тестовый tag `App=test5590`;
+- для channel block — `c=<canonical_channel_slug>`;
+- `data` содержит SHiNE Frame v1 (`frameCode=1`).
 
-При ошибках сервер отдаёт `Net_Exception_Response` со стандартными полями и дополнительно с состоянием сервера для ресинка:
+## Основные ошибки
 
-```json
-{
-  "op": "AddBlock",
-  "requestId": "req-1001",
-  "status": 400,
-  "ok": false,
-  "error": "bad_prev_hash",
-  "message": "Некорректный prevHash (цепочка не совпадает)",
-  "payload": {
-    "serverLastGlobalNumber": 11,
-    "serverLastGlobalHash": "c3d4...98"
-  }
-}
-```
+- `bad_app_tag` — отсутствует/неверен `App=test5590`;
+- `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 не парсится.
 
-### Основные `reasonCode`
+## Storage/publish
 
-- `empty_blockchain_name`, `bad_blockchain_name`
-- `blockchain_state_not_found`
-- `bad_block_base64`, `bad_block_format`, `bad_block_body`
-- `bad_block_number`, `req_global_mismatch`, `bad_prev_hash`
-- `bad_signature`, `signature_verify_failed`
-- `prev_line_block_not_found`, `bad_prev_line_hash`
-- `limit_exceeded`
-- `chain_resync_in_progress` — цепочка временно заблокирована полным resync
-- `repost_disabled` — репосты временно отключены до будущей реализации
-- `entrypoint_edit_forbidden` — `TEXT_ENTRYPOINT` нельзя редактировать через `TEXT_EDIT_POST`
-- `status_confirmed_target_must_be_status_action` — `STATUS_CONFIRMED` должен ссылаться на статусный блок
-- `status_action_target_not_allowed` — выбранный `STATUS_ACTION` нельзя ставить на этот тип материала
-- `bad_channel_meta_line`, `channel_not_found`, `bad_channel_meta_*`, `channel_meta_*_too_long` — ошибки `TEXT_CHANNEL_META`
-- `internal_error`
-
-## 5. Какие блоки реально можно добавлять через `AddBlock`
-
-Через `AddBlock` можно писать поддержанные форматы, кроме явно отключённых временных фич:
-
-1. **TECH (type=0)**
-   - `HEADER_COMPAT (subType=0)`
-   - `TECH_CREATE_CHANNEL (subType=1)`
-
-2. **TEXT (type=1)**
-   - `TEXT_POST (10)`
-   - `TEXT_EDIT_POST (11)`
-   - `TEXT_REPLY (20)`
-   - `TEXT_EDIT_REPLY (21)`
-   - `TEXT_RATING (30)` — target-based отзыв на конкретный блок
-   - `TEXT_REPOST (50)` — формат зарезервирован, но новые блоки временно отклоняются с `repost_disabled`
-   - `TEXT_CHANNEL_META (90)` — скрытый технический снимок профиля канала
-   - `TEXT_ENTRYPOINT (100)` — входная страница канала
-   - `TEXT_EXERCISE (110)` — line-based материал упражнения
-   - `TEXT_SERVICE (120)` — line-based материал услуги / процедуры
-   - `TEXT_COURSE (130)` — line-based материал курса
-
-3. **REACTION (type=2)**
-   - `REACTION_LIKE (1)`
-
-4. **CONNECTION (type=3)**
-   - `CONNECTION_FRIEND (10)`
-   - `CONNECTION_UNFRIEND (11)`
-   - `CONNECTION_CONTACT (20)`
-   - `CONNECTION_UNCONTACT (21)`
-   - `CONNECTION_FOLLOW (30)`
-   - `CONNECTION_UNFOLLOW (31)`
-   - `CONNECTION_SPOUSE (40)`
-   - `CONNECTION_UNSPOUSE (41)`
-   - `CONNECTION_PARENT (50)`
-   - `CONNECTION_UNPARENT (51)`
-   - `CONNECTION_CHILD (52)`
-   - `CONNECTION_UNCHILD (53)`
-   - `CONNECTION_SIBLING (54)`
-   - `CONNECTION_UNSIBLING (55)`
-   - `CONNECTION_KNOWN_PERSON (60)`
-   - `CONNECTION_UNKNOWN_PERSON (61)`
-   - `CONNECTION_SHINE_CONFIRMED (70)`
-   - `CONNECTION_SHINE_UNCONFIRMED (71)`
-   - `CONNECTION_SHINE_SEEN (74)`
-   - `CONNECTION_SHINE_UNSEEN (75)`
-
-5. **USER_PARAM (type=4)**
-   - `USER_PARAM_TEXT_TEXT (1)`
-
-6. **STATUS_ACTION (type=5)**
-   - `STATUS_DONE_ONCE (10)`
-   - `STATUS_LEARNED (20)`
-   - `STATUS_SERVICE_PASSED (30)`
-   - `STATUS_CONFIRMED (100)`
-   - `STATUS_INTERESTED (110)`
-   - `STATUS_STARTED (120)`
-   - `STATUS_IN_STUDY (130)`
-   - `STATUS_ABANDONED (140)`
-   - `STATUS_COMPLETED (150)`
-
-## 6. Практические payload-форматы для каналов и вложений
-
-`AddBlock` не имеет отдельных JSON-полей для вложений, аватаров или человекочитаемого имени канала. Клиент собирает бинарный блок нужного типа, а новые данные кладёт в текстовые поля тела блока по правилам blockchain-формата.
-
-### Вложения в сообщениях
-
-Для `TEXT_POST`, `TEXT_REPLY`, `TEXT_EDIT_POST` и `TEXT_EDIT_REPLY` вложения записываются в начало текста сообщения одним или несколькими тегами `S:att v=1`.
-
-Пример текстового содержимого body:
-
-```text
-<S:att;v=1;nm=photo.jpg;sz=248193;sha256=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;ar=BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB>
-<S:att;v=1;nm=report.pdf;sz=845221;sha256=cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc;ar=DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD>
-Текст сообщения
-```
-
-Пример вложения с отдельным preview-файлом:
-
-```text
-<S:att;v=1;nm=video.mp4;sz=5820193;sha256=bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;ar=CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC;preAr=DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;preSha256=eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee>
-```
-
-Сервер хранит это как обычный `TEXT`-блок. Отображение карусели, картинок, видео и карточек файлов делает клиент. Полная спецификация тега находится в `docs/Blockchain/15_TEXT_Attachments.md`.
-
-### Создание публичного канала с профилем
-
-Для публичного канала начальный профиль пишется одним блоком `TECH_CREATE_CHANNEL`. Поле `channelDescription` содержит meta-текст:
-
-```text
-<S:title;v=1;Человекочитаемое имя канала>
-<S:ava;v=1;sz=248193;sha256=3f2c8aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;ar=AbCdEfAbCdEfAbCdEfAbCdEfAbCdEfAbCdEfAbCdE>
-Описание канала
-```
-
-Ограничение `channelDescription` — до `2048` UTF-8 байт. Новый клиент не пишет отдельный `TEXT_CHANNEL_META` сразу после создания канала: создание канала и начальный профиль должны попадать в один `TECH_CREATE_CHANNEL`.
-
-### Изменение профиля канала
-
-Последующие изменения аватара, человекочитаемого имени или описания канала пишутся отдельным скрытым `TEXT_CHANNEL_META (subType=90)`.
-
-Текстовое содержимое body использует тот же формат полного снимка профиля:
-
-```text
-<S:title;v=1;Новое имя канала>
-<S:ava;v=1;sz=248193;sha256=3f2c8aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;ar=AbCdEfAbCdEfAbCdEfAbCdEfAbCdEfAbCdEfAbCdE>
-Новое описание канала
-```
-
-Каждый `TEXT_CHANNEL_META` является полным состоянием профиля на момент записи. Если аватара нет, тег `S:ava` не пишется. Если описания нет, после meta-тегов не добавляется хвостовой текст. Полная спецификация находится в `docs/Blockchain/16_TEXT_Channel_Meta.md`.
-
-## 7. Хватает ли функций сейчас
-
-Коротко: **для записи событий в блокчейн — хватает**, для полноценного клиентского чтения — **пока не хватает**.
-
-Что есть:
-- единый надёжный write-путь `AddBlock`;
-- есть `GetFriendsLists` и API по `UserParam`;
-- есть унифицированные коды ошибок и поля для ресинхронизации.
-
-Что пока ограничивает продукт:
-- нет полноценного read API для каналов/постов/тредов;
-- нет API списка подписок с серверными счётчиками непрочитанного;
-- нет ленты событий (новые ответы/лайки/подписки) как отдельного RPC.
-
-## 8. Рекомендации по клиенту при записи блоков
-
-1. Перед отправкой держать локальный `lastNumber/lastHash`.
-2. При `bad_prev_hash` или `bad_block_number`:
-   - взять `serverLastGlobalNumber/serverLastGlobalHash` из ошибки,
-   - пересобрать следующий блок на актуальной вершине.
-3. Для edit-блоков всегда ссылаться на **оригинальный** блок, а не на предыдущий edit.
-4. Для связей/подписок использовать target на **root** (HEADER или CREATE_CHANNEL), а не на произвольный пост.
-
-
-## 9. USER_PARAM для «личных данных»
-
-Да, на текущем API это можно добавить **без изменения серверного кода**:
-
-- в `UserParam` поле `param` сейчас не ограничено фиксированным справочником;
-- сервер хранит пары `param -> value` как строки (при наличии корректной подписи и `time_ms`);
-- чтение уже есть через `GetUserParam` и `ListUserParams`.
-
-Рекомендуемый стартовый набор ключей для профиля (MVP):
-
-- `name`
-- `last_name`
-- `address_physical`
-- `address_web`
-- `phone`
-
-Практическая рекомендация: заранее зафиксировать единый словарь ключей в клиенте/документации, чтобы избежать дублей вида `lastname` vs `last_name`, `site` vs `address_web` и т.д.
-
-Ограничения, которые важно учесть:
-
-- сейчас нет серверной ACL-политики чтения параметров (в MVP их может читать любой клиент, который знает `login`);
-- нет валидации формата значений для конкретных ключей (телефон, URL и т.д. проверяются только на стороне клиента);
-- нет отдельного индекса/поиска по этим полям — только точечное чтение и listing по `login`.
-
----
-
-## 10. `GetBlockchainBlock`
-
-### Назначение
-
-Публичное чтение одного конкретного блока из цепочки.
-
-Нужно для:
-
-- открытого чтения блокчейна по одному блоку;
-- межсерверной синхронизации;
-- восстановления/докачки отсутствующего хвоста цепочки.
-
-### JSON формат запроса
-
-`op = "GetBlockchainBlock"`.
-
-```json
-{
-  "op": "GetBlockchainBlock",
-  "requestId": "req-2001",
-  "payload": {
-    "blockchainName": "alice-001",
-    "blockNumber": 12
-  }
-}
-```
-
-Поля `payload`:
-
-- `blockchainName` — обязательно, формат `login-NNN`.
-- `blockNumber` — обязательно, номер блока в цепочке, `>= 0`.
-
-### Успешный ответ
-
-```json
-{
-  "op": "GetBlockchainBlock",
-  "requestId": "req-2001",
-  "status": 200,
-  "ok": true,
-  "payload": {
-    "blockchainName": "alice-001",
-    "blockNumber": 12,
-    "blockHash": "9f0eaabbccddeeff00112233445566778899aabbccddeeff0011223344556677",
-    "blockBytesB64": "AAAB..."
-  }
-}
-```
-
-### Ошибки
-
-- `400 / BAD_FIELDS` — некорректные `blockchainName` или `blockNumber`.
-- `404 / BLOCK_NOT_FOUND` — такого блока нет.
-- `500 / INTERNAL_ERROR` — внутренняя ошибка сервера.
+После успешного локального AddBlock полный DataItem хранится в PostgreSQL и ставится в Arweave publish queue. Импорт из Arweave использует ту же проверку, но не ставит блок на повторную публикацию.

docs/API/06_Channels_Read_API.md

@@ -14,19 +14,24 @@
 3. `GetMessageThread` — отдает дерево обсуждения вокруг конкретного сообщения:
    предки, фокус-сообщение, потомки.
 
-4. `GetPersonalDiary` — отдает виртуальную ленту `Личный дневник`, собранную из `STATUS_ACTION` текущего пользователя.
+4. `GetMessageLikes` — отдает списки пользователей, поставивших лайк сообщению,
+   сгруппированные для UI по статусу профиля.
 
-5. `GetChannelsCounters` — отдает счетчики разделов каналов для пользователя.
+5. `GetPersonalDiary` — отдает виртуальную ленту `Личный дневник`, собранную из `STATUS_ACTION` текущего пользователя.
 
-6. `ListGroupChats200` — отдает список групповых чатов типа `200`.
+6. `GetChannelsCounters` — отдает счетчики разделов каналов для пользователя.
 
-7. `GetGroupDialog` — отдает сообщения конкретного группового чата типа `200`.
+7. `SetChannelReadState` — сохраняет подписанный watermark чтения канала и возвращает новый unread-счетчик.
+
+8. `ListGroupChats200` — отдает список групповых чатов типа `200`.
+
+9. `GetGroupDialog` — отдает сообщения конкретного группового чата типа `200`.
 
 > На первом этапе мы **не используем курсоры** (`nextCursor`) и загружаем полные списки.
 >
-> `unreadCount` для канала считается по `user_settings`.
+> `unreadCount` для канала считается по подписанному состоянию чтения канала.
 > Для собственных каналов владельцу всегда возвращается `unreadCount = 0`, чтобы его собственные публикации не становились «новыми» для него самого.
-> Если для пары `ownerBlockchainName/channelName` ещё нет записи, канал временно считается полностью прочитанным; UI при загрузке списка каналов создаёт baseline на текущем `messagesCount`. После этого новые публикации увеличивают `unreadCount` до продвижения курсора чтения.
+> Если для пары `ownerBlockchainName/channelName` ещё нет записи, канал временно считается полностью прочитанным. После появления записи новые публикации увеличивают `unreadCount` до продвижения курсора чтения.
 
 ---
 
@@ -107,6 +112,9 @@
           "channelRoot": { "blockNumber": 456, "blockHash": "..." }
         },
         "messagesCount": 90,
+        "readCount": 0,
+        "unreadCount": 0,
+        "readStateInitialized": false,
         "lastMessage": {
           "messageRef": { "blockNumber": 1002, "blockHash": "..." },
           "text": "актуальный текст",
@@ -141,6 +149,8 @@
 }
 ```
 
+`limit` необязателен. Если поле отсутствует или равно `0`, сервер возвращает всю ленту канала. Положительное значение ограничивает количество сообщений для совместимых клиентов.
+
 ### Response (success)
 ```json
 {
@@ -266,7 +276,63 @@
 
 ---
 
-## 4) GetPersonalDiary
+## 4) GetMessageLikes
+
+Возвращает пользователей, которые поставили лайк конкретному сообщению канала.
+
+- `message.blockchainName`, `message.blockNumber`, `message.blockHash` должны указывать на исходное сообщение.
+- `limit` в текущей реализации не требуется: сервер возвращает полный найденный список лайков.
+- Пользователи группируются по состоянию профиля:
+  - `shining` — `account_role=primary` и `shine_status=shining`;
+  - `official` — `account_role=primary`, но без `shine_status=shining`;
+  - `others` — остальные пользователи.
+
+### Request
+```json
+{
+  "op": "GetMessageLikes",
+  "requestId": "req-4",
+  "payload": {
+    "message": {
+      "blockchainName": "bob-001",
+      "blockNumber": 140,
+      "blockHash": "..."
+    }
+  }
+}
+```
+
+### Response (success)
+```json
+{
+  "op": "GetMessageLikes",
+  "requestId": "req-4",
+  "status": 200,
+  "ok": true,
+  "payload": {
+    "shining": [
+      { "login": "Alice", "firstName": "Alice", "lastName": "", "avatarAr": "ArweaveTxId..." }
+    ],
+    "official": [],
+    "others": [
+      { "login": "Carl", "firstName": "", "lastName": "", "avatarAr": "" }
+    ],
+    "total": 2,
+    "truncated": false
+  }
+}
+```
+
+### Ошибки
+- `bad_fields` — не передан `message` или обязательные поля ссылки на сообщение.
+- `bad_hash` — `message.blockHash` не является корректным hex-хэшем блока.
+- `internal_error` — внутренняя ошибка чтения.
+
+`truncated` сейчас всегда `false`; поле оставлено в ответе для совместимости с UI и возможной будущей пагинацией.
+
+---
+
+## 5) GetPersonalDiary
 
 Возвращает виртуальный канал `Личный дневник` для самого пользователя.
 
@@ -289,7 +355,7 @@
 
 ---
 
-## 4) GetChannelsCounters
+## 6) GetChannelsCounters
 
 ### Request
 ```json
@@ -321,7 +387,69 @@
 
 ---
 
-## 5) ListGroupChats200
+## 7) SetChannelReadState
+
+Сохраняет подписанную позицию чтения для одного канала, на который пользователь подписан.
+
+- Требует авторизованное WebSocket-соединение.
+- `login` должен совпадать с текущим авторизованным пользователем.
+- Подпись строится client key пользователя по строке:
+
+```text
+SHiNe/ChannelReadState:<login>|<owner_bch_name>|<channel_name>|<time_ms>|<read_count>
+```
+
+### Request
+```json
+{
+  "op": "SetChannelReadState",
+  "requestId": "req-7",
+  "payload": {
+    "login": "Alice",
+    "owner_bch_name": "bob-001",
+    "channel_name": "news",
+    "read_count": 90,
+    "time_ms": 1760000000000,
+    "client_key": "<base64-client-public-key>",
+    "signature": "<base64-ed25519-signature>"
+  }
+}
+```
+
+### Response (success)
+```json
+{
+  "op": "SetChannelReadState",
+  "requestId": "req-7",
+  "status": 200,
+  "ok": true,
+  "payload": {
+    "login": "Alice",
+    "owner_bch_name": "bob-001",
+    "channel_name": "news",
+    "read_count": 90,
+    "unread_count": 0,
+    "time_ms": 1760000000000,
+    "applied": true
+  }
+}
+```
+
+### Ошибки
+- `NOT_AUTHENTICATED` — нет авторизованной сессии.
+- `BAD_FIELDS` — не переданы обязательные поля.
+- `LOGIN_MISMATCH` — `login` не совпадает с текущей сессией.
+- `BAD_TIME` — время подписи слишком далеко в будущем.
+- `BAD_BASE64` — `client_key` или `signature` не являются корректным Base64.
+- `DEVICE_KEY_MISMATCH` — `client_key` не совпадает с текущим client key пользователя.
+- `INVALID_SIGNATURE` — подпись watermark не прошла проверку.
+- `CHANNEL_NOT_FOLLOWED` — пользователь не подписан на канал.
+- `CHANNEL_NOT_FOUND` — канал не найден.
+- `INTERNAL_ERROR` — внутренняя ошибка записи.
+
+---
+
+## 8) ListGroupChats200
 
 ### Request
 ```json
@@ -361,7 +489,7 @@
 
 ---
 
-## 6) GetGroupDialog
+## 9) GetGroupDialog
 
 ### Request
 ```json
@@ -414,8 +542,10 @@
 - `user_not_found`
 - `channel_not_found`
 - `message_not_found`
-- `limit_too_large`
+- `bad_limit`
 - `channel_name_already_exists`
+- `CHANNEL_NOT_FOLLOWED`
+- `CHANNEL_NOT_FOUND`
 - `internal_error`
 
 ---

docs/API/07_Channels_Feature_Runbook.md

@@ -8,6 +8,8 @@
    - `ListSubscriptionsFeed` — экран списка каналов.
    - `GetChannelMessages` — сообщения конкретного канала.
    - `GetMessageThread` — дерево обсуждения для сообщения.
+   - `GetMessageLikes` — списки пользователей, поставивших лайк сообщению.
+   - `SetChannelReadState` — подписанный watermark чтения канала.
 
 2. **UI вкладки Каналы**:
    - при открытии пытается загрузить реальный feed с сервера;
@@ -33,12 +35,16 @@
 1. Вызвать `ListSubscriptionsFeed`.
 2. Для канала `ownedChannels[0]` вызвать `GetChannelMessages`.
 3. Для первого `messages[0]` вызвать `GetMessageThread`.
+4. Для первого `messages[0]` вызвать `GetMessageLikes`.
+5. Для подписанного канала вызвать `SetChannelReadState` с текущим `messagesCount`.
 
 ### Ошибки
 1. `ListSubscriptionsFeed` с пустым login -> `bad_fields`.
 2. `GetChannelMessages` с битым channel payload -> `bad_fields`.
 3. `GetMessageThread` с несуществующим block -> `message_not_found`.
-4. `AddBlock(CreateChannel)` с уже существующим именем -> `channel_name_already_exists`.
+4. `GetMessageLikes` с битым `message.blockHash` -> `bad_hash`.
+5. `SetChannelReadState` без активной подписки -> `CHANNEL_NOT_FOLLOWED`.
+6. `AddBlock(CreateChannel)` с уже существующим именем -> `channel_name_already_exists`.
 
 ---
 
@@ -91,6 +97,38 @@
 }
 ```
 
+## 3.4 GetMessageLikes
+```json
+{
+  "op": "GetMessageLikes",
+  "requestId": "debug-likes-1",
+  "payload": {
+    "message": {
+      "blockchainName": "TestUser1-001",
+      "blockNumber": 123,
+      "blockHash": "<hash-from-GetChannelMessages>"
+    }
+  }
+}
+```
+
+## 3.5 SetChannelReadState
+```json
+{
+  "op": "SetChannelReadState",
+  "requestId": "debug-read-state-1",
+  "payload": {
+    "login": "TestUser1",
+    "owner_bch_name": "TestUser2-001",
+    "channel_name": "news",
+    "read_count": 25,
+    "time_ms": 1760000000000,
+    "client_key": "<base64-client-public-key>",
+    "signature": "<base64-ed25519-signature>"
+  }
+}
+```
+
 ---
 
 ## 4) Что смотреть в ответах
@@ -101,6 +139,8 @@
 - у каждой записи есть:
   - `channel.channelRoot.blockNumber`,
   - `messagesCount`,
+  - `unreadCount`,
+  - `readStateInitialized`,
   - `lastMessage` (может быть null, если сообщений нет).
 
 ### GetChannelMessages
@@ -115,6 +155,16 @@
 - у узлов должны быть версии и счетчики.
 - у каждого узла дополнительно может приходить `rawBlockB64` (Base64 сырого `block_bytes`).
 
+### GetMessageLikes
+- `payload.shining[]`, `payload.official[]`, `payload.others[]` — группы пользователей.
+- у каждого пользователя есть `login`, `firstName`, `lastName`, `avatarAr`.
+- `payload.truncated` сейчас всегда `false`; поле оставлено для совместимости и будущей пагинации.
+
+### SetChannelReadState
+- `payload.read_count` — сохраненная позиция чтения.
+- `payload.unread_count` — пересчитанный unread для канала.
+- `payload.applied=false` означает, что на сервере уже была более новая signed-позиция.
+
 ### Важно по совместимости
 - `rawBlockB64` добавлен только в `GetMessageThread`.
 - `GetChannelMessages` не содержит `rawBlockB64` (без изменений формата ленты).

docs/API/09_Operations_Index.md

@@ -14,8 +14,6 @@
 | --- | --- | --- |
 | `GetUser` | `01_User_Registration_API.md` | чтение/проверка пользователя + server-состояние его блокчейна |
 | `SearchUsers` | `01_User_Registration_API.md` | поиск логинов по префиксу |
-| `TestGetFreeAvatarQuota` | `14_Test_Free_Avatar_Upload_API.md` | временный тестовый просмотр остатка бесплатных загрузок аватара |
-| `TestUploadFreeAvatar` | `14_Test_Free_Avatar_Upload_API.md` | временная тестовая бесплатная загрузка маленького аватара в Arweave |
 | `ResolveLoginForAuth` | `02_Authentication_API.md` | проверка login перед входом: LOCAL / REMOTE / NOT_FOUND / NO_ACCESS_SERVER + URL правильного access server |
 | `AuthChallenge` | `02_Authentication_API.md` | challenge для создания новой сессии |
 | `CreateAuthSession` | `02_Authentication_API.md` | создание новой авторизованной сессии |
@@ -46,8 +44,10 @@
 | `ListSubscriptionsFeed` | `06_Channels_Read_API.md` | лента каналов/подписок |
 | `GetChannelMessages` | `06_Channels_Read_API.md` | сообщения канала |
 | `GetMessageThread` | `06_Channels_Read_API.md` | тред сообщения |
+| `GetMessageLikes` | `06_Channels_Read_API.md` | списки пользователей, поставивших лайк сообщению |
 | `GetPersonalDiary` | `06_Channels_Read_API.md` | виртуальный канал `Личный дневник` из STATUS_ACTION |
 | `GetChannelsCounters` | `06_Channels_Read_API.md` | счетчики разделов каналов |
+| `SetChannelReadState` | `06_Channels_Read_API.md` | подписанный watermark чтения канала |
 | `ListGroupChats200` | `06_Channels_Read_API.md` | список групповых чатов типа `200` |
 | `GetGroupDialog` | `06_Channels_Read_API.md` | сообщения группового чата типа `200` |
 | `UpsertUserParam` | `10_User_Params_API.md` | запись параметра пользователя |
@@ -80,6 +80,6 @@
   входящей копии на единственный access-сервер получателя.
 - Межсерверные DM-операции пока доверяют `sourceServerLogin`; отдельная межсерверная авторизация запланирована позднее.
 - `ServerHello` пока принимает заявленный `serverLogin` на доверии и не является криптографической аутентификацией.
-- Отдельных HTTP endpoints для DM-файлов сейчас нет.
+- HTTP endpoints зашифрованных DM-файлов (`PUT/GET/HEAD/OPTIONS /dm-files/{fileId}`) не являются WebSocket `op` и описаны отдельно в `18_DM_File_Storage_API.md`.
 - Классы `Net_MarkChannelMessagesSeen_*` существуют в коде, но операция `MarkChannelMessagesSeen` не зарегистрирована в `JsonHandlerRegistry`, поэтому в публичный список API не входит.
 - HTTP debug endpoints из `src/main/java/server/debug/` не входят в этот индекс WebSocket `op`; они описаны отдельно в `13_HTTP_Debug_API.md`.

docs/API/18_DM_File_Storage_API.md

@@ -0,0 +1,113 @@
+# HTTP API зашифрованных файлов личных сообщений
+
+## 1. Назначение
+
+Файлы личных сообщений хранятся только на access-сервере отправителя и только в зашифрованном виде.
+HTTP API не получает исходное имя файла, MIME-тип или ключ расшифрования.
+
+Клиент:
+
+1. генерирует случайный AES-256-GCM key и 96-bit IV;
+2. шифрует файл в браузере;
+3. считает `SHA-256(ciphertext)`;
+4. переводит 32-byte hash в Base58 — это `fileId` и имя файла на диске сервера;
+5. загружает ciphertext на свой access-сервер;
+6. помещает URL, key, IV, исходное имя/MIME/размер в `<S:file...>` внутри plaintext DM;
+7. обычный механизм E2EE DM шифрует эту техническую вставку отдельно для отправителя и получателя.
+
+Следствие: сервер файлов не знает AES-key и не может расшифровать вложение.
+
+## 2. Конфигурация сервера
+
+```properties
+dm.files.enabled=true
+dm.files.storageDir=data/dm-files
+dm.files.maxBytes=52428816
+```
+
+`dm.files.maxBytes` ограничивает размер одного ciphertext-объекта. Для legacy DM file v1 это фактически ограничивало целый файл. В DM file v2 файл состоит из 1-MiB ciphertext-объектов, поэтому общий размер логического файла этим параметром не ограничивается.
+
+## 3. PUT `/dm-files/{fileId}`
+
+Загружает immutable ciphertext.
+
+`fileId` обязан быть равен:
+
+```text
+Base58(SHA-256(ciphertext))
+```
+
+### Заголовки авторизации
+
+```text
+Content-Type: application/octet-stream
+X-Shine-Session-Id: <active session id>
+X-Shine-Time-Ms: <unix time ms>
+X-Shine-Content-Length: <ciphertext bytes>
+X-Shine-Signature: <Ed25519 signature, Base64>
+```
+
+Подписываемая UTF-8 строка:
+
+```text
+DM_FILE_UPLOAD_V1:{sessionId}:{fileId}:{encryptedSize}:{timeMs}
+```
+
+Подпись проверяется публичным `session_key` из активной сессии. Допустимое отклонение времени — 60 секунд.
+
+Сервер потоково пишет временный файл, одновременно считает SHA-256, проверяет фактический размер и только после успешной проверки атомарно перемещает объект под именем `{fileId}`.
+
+Повторная корректно подписанная загрузка уже существующего immutable объекта идемпотентна. Перед ответом `alreadyExists=true` сервер повторно вычисляет `SHA-256` уже сохранённого объекта и сверяет его с `fileId`; одного совпадения имени файла на диске недостаточно. Если объект повреждён или подменён, сервер удаляет некорректную копию и принимает корректный `PUT` заново.
+
+Успешный ответ:
+
+```json
+{
+  "ok": true,
+  "fileId": "...",
+  "size": 12345,
+  "alreadyExists": false
+}
+```
+
+Основные ошибки: `BAD_FILE_ID`, `MISSING_UPLOAD_AUTH`, `UPLOAD_AUTH_EXPIRED`, `BAD_UPLOAD_SIGNATURE`, `FILE_TOO_LARGE`, `LENGTH_MISMATCH`, `HASH_MISMATCH`.
+
+## 4. GET `/dm-files/{fileId}`
+
+Возвращает только сохранённый ciphertext как `application/octet-stream`.
+
+GET не требует пользовательской сессии: `fileId` является непредсказуемым 256-bit content address, а без AES-key содержимое остаётся зашифрованным. AES-key передаётся только внутри E2EE DM.
+
+Ответ разрешает cross-origin чтение (`Access-Control-Allow-Origin: *`), потому что получатель может быть подключён к другому access-серверу и должен скачать ciphertext непосредственно с сервера отправителя.
+
+Перед расшифрованием официальный UI повторно проверяет `Base58(SHA-256(downloadedCiphertext)) == fileId`.
+
+## 5. HEAD и OPTIONS
+
+- `HEAD /dm-files/{fileId}` возвращает метаданные ciphertext без тела только после повторной проверки `Base58(SHA-256(ciphertext)) == fileId`; официальный UI использует этот запрос перед `PUT`, чтобы не отправлять уже существующие байты повторно;
+- `OPTIONS /dm-files/*` обслуживает CORS preflight для браузерного PUT.
+
+## 6. Reverse proxy
+
+Caddy/Nginx должен проксировать `/dm-files/*` в тот же Jetty, что обслуживает `/ws`. Route должен находиться до SPA fallback.
+
+## 7. Ограничения legacy v1
+
+- legacy-файл перед загрузкой целиком читается в память браузера и ограничен 50 MiB;
+- новые отправки официального UI используют v2 и этого ограничения не имеют;
+- удаления/TTL/garbage collection пока нет;
+- если ciphertext уже загружен, а отправка E2EE DM затем не удалась, объект может остаться orphan-файлом;
+- resumable/chunked upload не входит в v1.
+
+## 8. DM file v2: большие файлы
+
+Начиная с UI v2 один логический файл не загружается одним HTTP-объектом. Клиент режет plaintext на `1 MiB` части и каждый AES-GCM ciphertext-кусок загружает отдельным обычным `PUT /dm-files/{fileId}`.
+
+Поэтому `dm.files.maxBytes` — это лимит **одного immutable HTTP-объекта**, а не всего пользовательского файла. При стандартном `chunkSize=1 MiB` общий размер файла этим параметром не ограничивается.
+
+Манифест также хранится через тот же immutable API:
+
+- encrypted manifest page — до 256 chunk descriptors;
+- encrypted root manifest — ссылки на страницы + BitTorrent v2 root metadata.
+
+Никаких новых доверенных серверных операций для v2 не требуется: сервер по-прежнему только проверяет подпись PUT, длину и `Base58(SHA-256(ciphertext))`.

docs/Blockchain/01_Common_Block_Format.md

@@ -1,49 +1,116 @@
-# Общий формат добавляемого блока (Frame v0)
+# Общий формат пользовательского блока SHiNE — Frame v1 / ANS-104
 
-Этот файл описывает **единый бинарный формат** блока, который клиент отправляет через `AddBlock` в поле `blockBytesB64`.
+Актуальный формат не поддерживает старый Frame v0. Новый пользовательский блок сразу создаётся как готовый подписанный ANS-104 DataItem.
 
-## 1. Полная структура блока
+## 1. Два уровня формата
 
-Блок состоит из двух частей:
+Полный объект, который клиент отправляет в `AddBlock`, хранится в PostgreSQL и затем архивируется в Arweave:
 
-1. **PREIMAGE** (подписывается)
-2. **TAIL** (маркер подписи + подпись)
+```text
+ANS-104 DataItem
+  signature_type = 2 (generic Ed25519)
+  signature      = 64 bytes
+  owner          = 32-byte blockchain public key
+  target         = absent
+  anchor         = absent
+  tags
+  data           = SHiNE Frame v1
+```
 
-### PREIMAGE
+Цепочка SHiNE **не зависит от Arweave**. Arweave DataItem ID хранится отдельно и используется для дедупликации/поиска, но не является `prevHash`.
 
-- `frameCode (uint16)`
-- `prevHash32 (32 bytes)`
-- `blockSize (int32)` — размер PREIMAGE
-- `blockNumber (int32)`
-- `timestamp (int64)`
-- `type (uint16)`
-- `subType (uint16)`
-- `version (uint16)`
-- `bodyBytes (N)`
+## 2. SHiNE Frame v1
 
-### TAIL
+Все целые поля Frame v1 — BigEndian.
 
-- `sigMarker (uint16)`
-- `signature64 (64 bytes, Ed25519)`
+| Поле | Размер | Описание |
+|---|---:|---|
+| `frameCode` | 2 | `0x0001` |
+| `prevHash32` | 32 | SHA-256 полного Frame v1 предыдущего SHiNE-блока; для блока 0 — нули |
+| `blockSize` | 4 | точный размер Frame v1, включая header и body |
+| `blockNumber` | 4 | номер блока, начиная с 0 |
+| `timestamp` | 8 | Unix time seconds |
+| `type` | 2 | тип сообщения |
+| `subType` | 2 | подтип |
+| `version` | 2 | версия body |
+| `body` | N | данные конкретного типа |
 
-## 2. Что проверяет сервер при AddBlock
+`FRAME_HEADER_SIZE = 56` bytes.
 
-- `frameCode` должен быть `0x0000`.
-- `sigMarker` должен быть `0x0100`.
-- `blockNumber` должен идти строго по порядку (`last + 1`).
-- `prevHash32` должен совпасть с вершиной цепочки на сервере.
-- `body` должен пройти `check()` для конкретного типа.
-- подпись должна валидироваться публичным ключом блокчейна.
+```text
+blockHash32 = SHA256(FrameV1Bytes)
+next.prevHash32 = blockHash32
+```
 
-## 3. Ограничения
+Подписи внутри Frame v1 нет. Единственная подпись пользователя — подпись окружающего ANS-104 DataItem.
 
-- максимальный полный размер блока: до 4 MiB;
-- timestamp не должен сильно уходить в будущее;
-- `bodyBytes` парсится по `type/subType/version` из заголовка блока.
+## 3. ANS-104 DataItem
 
-## 4. Почему это важно
+Для тестового контура используется generic Ed25519 signature type `2`: подпись 64 bytes, owner 32 bytes. Это отдельный generic Ed25519 signer type; Solana-specific signer в текущем Turbo/arbundles имеет другой type.
 
-Одинаковый общий формат позволяет:
-- передавать разные виды записей через один RPC `AddBlock`;
-- валидировать блоки единообразно;
-- расширять типы `body`, не ломая каркас блока.
+Подписывается стандартный ANS-104 deep-hash:
+
+```text
+[
+  "dataitem",
+  "1",
+  "2",
+  owner,
+  target(empty),
+  anchor(empty),
+  rawAvroTags,
+  FrameV1Bytes
+]
+```
+
+`rawAvroTags` — ровно те Avro-serialized bytes тегов, которые лежат внутри DataItem.
+
+`dataItemId32 = SHA256(signature64)`.
+
+### Обязательный тестовый тег
+
+Каждый блок:
+
+```text
+App = test5590
+```
+
+Это временное namespace-значение для разработки. Перед реальным запуском оно будет заменено отдельным изменением протокола/кода.
+
+### Канальный тег
+
+Если блок относится к конкретному каналу, он дополнительно содержит:
+
+```text
+c = <canonical_channel_slug>
+```
+
+Slug входит в подпись DataItem и не может быть изменён сервером после подписи.
+
+## 4. Что хранится в PostgreSQL
+
+`blocks.block_bytes` содержит **полный serialized ANS-104 DataItem**, а не только Frame.
+
+Отдельно индексируются:
+
+- `block_hash` — SHA-256(Frame v1);
+- `block_signature` — 64-byte Ed25519 signature из DataItem;
+- `data_item_id` — SHA-256(signature), UNIQUE;
+- `block_number`, `bch_name`, message fields;
+- состояние публикации в Arweave.
+
+Локальные `.bch`, `.tmp_bch` и marker-файлы для пользовательских blockchain больше не используются.
+
+## 5. Проверка AddBlock
+
+Сервер обязан:
+
+1. распарсить полный ANS-104 DataItem;
+2. проверить `App=test5590`;
+3. проверить `c`, если тип блока требует канал;
+4. проверить ANS-104 Ed25519 подпись;
+5. проверить, что `owner` равен текущему blockchain public key пользователя;
+6. распарсить Frame v1 и body;
+7. проверить `blockNumber == last + 1`;
+8. проверить `prevHash32 == lastBlockHash`;
+9. записать DataItem и новое состояние атомарно в PostgreSQL.

docs/Blockchain/17_ANS104_Arweave_Transport.md

@@ -0,0 +1,97 @@
+# ANS-104 / Arweave transport для пользовательских блоков SHiNE
+
+## Цель
+
+Каждый пользовательский блок уже на клиенте является самостоятельным подписанным ANS-104 DataItem. Сервер не переподписывает пользовательский контент: он проверяет его, хранит в PostgreSQL и объединяет готовые DataItems в стандартный ANS-104 bundle.
+
+## Child DataItem tags
+
+Обязательно для тестового контура:
+
+```text
+App=test5590
+```
+
+Дополнительно для блоков конкретного канала:
+
+```text
+c=<canonical_channel_slug>
+```
+
+Теги входят в ANS-104 подпись пользователя.
+
+## Publisher
+
+По умолчанию цикл — раз в 15 минут.
+
+```text
+blocks.arweave_publish_pending=true
+        ↓
+готовые serialized DataItems
+        ↓
+ANS-104 binary bundle
+        ↓
+обычная Arweave L1 transaction
+```
+
+Если pending-блоков нет, транзакция не создаётся.
+
+Root transaction содержит стандартные bundle tags:
+
+```text
+Bundle-Format=binary
+Bundle-Version=2.0.0
+Content-Type=application/octet-stream
+App=test5590-batch
+```
+
+`App=test5590-batch` намеренно отличается от child `App=test5590`, чтобы discovery-запрос находил пользовательские блоки, а не root bundles.
+
+После успешной L1-загрузки сервер ставит child-блокам:
+
+- `arweave_publish_pending=false`;
+- `arweave_published_at_ms`;
+- `arweave_root_tx_id`.
+
+## Importer
+
+Каждый сервер может независимо искать:
+
+```text
+App=test5590
+```
+
+через GraphQL gateway с cursor pagination.
+
+Для каждого нового DataItem:
+
+1. взять `id` и `bundledIn.id`;
+2. получить root bundle;
+3. извлечь точные serialized bytes child DataItem по bundle index;
+4. проверить `dataItemId == SHA256(signature)`;
+5. проверить ANS-104 Ed25519 подпись;
+6. определить пользователя по `owner`;
+7. применить обычные проверки `AddBlock`;
+8. записать в PostgreSQL с `arweave_publish_pending=false`.
+
+### Блоки могут прийти не по порядку
+
+Discovery/import использует persistent queue `arweave_block_import_queue`. Если, например, block 102 увиден раньше block 101, block 102 остаётся `PENDING`; после появления 101 очередь повторно проигрывается.
+
+## Дедупликация и несколько серверов
+
+Один и тот же готовый DataItem имеет один `data_item_id = SHA256(signature)`. Если несколько серверов включили его в разные root bundles, локально это всё равно один логический блок: `blocks.data_item_id` уникален.
+
+Импортированный из Arweave блок **не ставится обратно в publish queue**. Это предотвращает бесконечное переархивирование между серверами.
+
+## Локальное хранение
+
+Пользовательские blockchain-файлы на диске больше не используются. Полный serialized DataItem находится в `blocks.block_bytes` PostgreSQL.
+
+## Настройки
+
+См. `application.properties` и `CODEX_APPLY_ANS104_TEST5590_PATCH.md`.
+
+## Что намеренно не входит в этот патч
+
+Remote/homeserver signing path, связанный с внешним homeserver/ESP32 signer, не мигрируется этим патчем. Каталог `ESP32/` не изменяется. До отдельной миграции новый Frame v1/ANS-104 production path рассчитан на клиент, у которого локально доступен blockchain Ed25519 key.

docs/Blockchain/CHANGELOG.md

@@ -236,3 +236,16 @@
 - Добавлена поддержка командного префикса `/.` и команды `/.desc` для актуализации описания канала при чтении.
 - Зафиксированы команды `/.add` и `/.remove` для каналов `type=200` (зарезервировано под расширение участниками).
 - В `AGENTS.md` добавлено обязательное правило актуализации документации в `docs/Blockchain/`.
+
+## 2026-09-20 — Frame v1 + ANS-104 DataItem / Arweave per-block transport
+
+- Основание: пользователь явно подтвердил breaking change и запуск с чистой историей; patch archive, commit hash ещё отсутствует.
+- Удалена поддержка старого Frame v0 (`preimage + sigMarker + signature`).
+- Новый пользовательский block — SHiNE Frame v1 внутри стандартного ANS-104 DataItem, generic Ed25519 signature type 2.
+- Signing message синхронизирован с фактическим arbundles/Turbo DataItem: включает строку signature type и raw Avro tag bytes.
+- SHiNE chain hash остаётся независимым: `SHA256(FrameV1Bytes)`; Arweave DataItem ID хранится отдельно.
+- В тестовом контуре каждый DataItem подписывает tag `App=test5590`; channel blocks дополнительно `c=<canonical slug>`.
+- PostgreSQL стал единственным локальным хранилищем пользовательских block bytes; `.bch/.tmp_bch/marker` storage/recovery удалён.
+- Старый custom `SHINE-ARCHIVE` pipeline удалён. Добавлены standard ANS-104 bundle publisher через существующий Arweave L1 uploader и GraphQL importer.
+- Импортированные из Arweave blocks не публикуются повторно; дедупликация идёт по `data_item_id`.
+- ESP32 и связанный device code этим изменением не затронуты.

docs/Blockchain/CODEX_APPLY_ANS104_TEST5590_PATCH.md

@@ -0,0 +1,108 @@
+# Инструкция Codex: применить ANS-104 test5590 patch
+
+## Цель
+
+Перевести пользовательский blockchain SHiNE на Frame v1 внутри готовых ANS-104 DataItems и убрать старый SHINE-ARCHIVE/файловое хранение цепочек.
+
+## Жёсткое ограничение
+
+**Не изменять ничего в `ESP32/`.** В этом patch нет ни одного файла `ESP32/**`.
+
+Remote/homeserver signer, завязанный на устройство, намеренно не мигрирован. Не пытаться «заодно исправить» его в рамках этого patch.
+
+## Применение
+
+1. Распаковать patch поверх корня репозитория, сохраняя относительные пути.
+2. Удалить все пути из корневого `DELETE_FILES.txt`.
+3. Проверить, что `git diff -- ESP32` пуст.
+4. Использовать чистую/dev test DB. `migration_v24.sql` намеренно откажется мигрировать непустую blockchain DB, потому что backward compatibility со старым block format не требуется.
+
+## Arweave config
+
+Минимально для публикации:
+
+```properties
+arweave.blocks.publish.enabled=true
+arweave.blocks.publish.intervalMinutes=15
+arweave.blocks.publish.gateway=https://arweave.net
+arweave.blocks.publish.walletJwkPath=/ABSOLUTE/SECRET/PATH/arweave-wallet.json
+```
+
+JWK не коммитить.
+
+Для discovery/import:
+
+```properties
+arweave.blocks.sync.enabled=true
+arweave.blocks.sync.intervalMinutes=15
+arweave.blocks.sync.gateway=https://turbo-gateway.com
+arweave.blocks.sync.startBlockHeight=0
+```
+
+На тестах желательно установить `startBlockHeight` на высоту начала `test5590`, чтобы не сканировать лишнюю историю.
+
+## Test namespace
+
+Child DataItem:
+
+```text
+App=test5590
+```
+
+Channel child:
+
+```text
+App=test5590
+c=<canonical_channel_slug>
+```
+
+Root bundle:
+
+```text
+Bundle-Format=binary
+Bundle-Version=2.0.0
+App=test5590-batch
+```
+
+Перед production-start test namespace должен быть заменён отдельным осознанным изменением.
+
+## Проверки после применения
+
+Из корня репозитория:
+
+```bash
+node --check shine-UI/js/services/ans104-data-item.js
+node --check shine-UI/js/services/auth-service.js
+node --check shine-UI/js/app.js
+node --check shine-UI/js/pages/settings-view.js
+```
+
+Java/Gradle:
+
+```bash
+./gradlew testClasses
+./gradlew test
+```
+
+Затем локальный smoke test по штатной инструкции проекта, например `./gradlew startLocal`.
+
+В среде, где готовился patch, Gradle wrapper не смог скачать Gradle 8.14 из-за отсутствия внешнего сетевого доступа к `services.gradle.org`. Поэтому полный Gradle compile/test обязательно прогнать после применения в обычной dev-среде.
+
+## Smoke scenario
+
+1. Создать/использовать тестового пользователя с локальным blockchain Ed25519 key.
+2. Добавить обычный block и убедиться, что `blocks.block_bytes` начинается с ANS-104 DataItem, а `data_item_id` заполнен.
+3. Создать channel и post; проверить `c=<canonical slug>`.
+4. Включить publisher, дождаться цикла или вызвать сервис тестом; проверить root Arweave tx.
+5. На второй чистой test DB включить importer и убедиться, что `App=test5590` blocks восстанавливаются в правильном порядке.
+6. Убедиться, что imported blocks имеют `arweave_publish_pending=false`.
+7. Проверить, что повторный discovery не создаёт дублей.
+
+## Не делать в этом patch
+
+- не добавлять backward compatibility Frame v0;
+- не возвращать `.bch` storage;
+- не возвращать SHINE-ARCHIVE;
+- не менять ESP32;
+- не мигрировать remote/homeserver signing без отдельного решения пользователя;
+- не заменять `prevHash` на Arweave DataItem ID.

docs/Blockchain/README.md

@@ -1,47 +1,40 @@
-# Документация блокчейна SHiNE (MVP)
+# SHiNE Blockchain
 
-Этот каталог описывает только текущий рабочий формат протокола для MVP.
+Актуальная версия пользовательского blockchain использует **SHiNE Frame v1 внутри подписанного ANS-104 DataItem**. Старый Frame v0 и файловое хранение `.bch` не поддерживаются.
 
 ## Основные документы
-1. [01_Common_Block_Format.md](./01_Common_Block_Format.md)
-   Единый бинарный формат блока (Frame v0), подпись, базовые проверки.
-2. [02_Blockchain_Kinds_and_Lines.md](./02_Blockchain_Kinds_and_Lines.md)
-   Виды цепочек и правила line-полей.
-3. [10_TECH_Blocks.md](./10_TECH_Blocks.md)
-   Системные блоки (`msg_type=0`).
-4. [11_TEXT_Blocks.md](./11_TEXT_Blocks.md)
-   Текстовые блоки (`msg_type=1`).
-5. [12_REACTION_Blocks.md](./12_REACTION_Blocks.md)
-   Реакции (`msg_type=2`).
-6. [13_CONNECTION_Blocks.md](./13_CONNECTION_Blocks.md)
-   Социальные связи (`msg_type=3`).
-7. [14_USER_PARAM_Blocks.md](./14_USER_PARAM_Blocks.md)
-   Параметры пользователя (`msg_type=4`).
-8. [15_STATUS_ACTION_Blocks.md](./15_STATUS_ACTION_Blocks.md)
-   Статусные действия пользователя (`msg_type=5`).
-9. [16_TEXT_Attachments.md](./16_TEXT_Attachments.md)
-   Вложения в TEXT-сообщениях через `S:att v=1`, включая опциональные `preAr/preSha256` для видео и крупных изображений.
-10. [16_TEXT_Channel_Meta.md](./16_TEXT_Channel_Meta.md)
-   Скрытый `TEXT_CHANNEL_META` для профиля канала.
-11. [01_Channel_Types_and_CreateChannel.md](./01_Channel_Types_and_CreateChannel.md)
-   Типы каналов и формат `CreateChannelBody`.
-12. [02_Channel_Commands.md](./02_Channel_Commands.md)
-   Команды в текстовых сообщениях каналов.
-13. [CHANGELOG.md](./CHANGELOG.md)
-    Журнал изменений документации.
 
-## Смежная документация
-- [../ИТХ/README.md](../ИТХ/README.md) — ежедневное закрытие блокчейна (ИТХ): краткий обзор.
-- [../ИТХ/Спецификация_ИТХ_v1.md](../ИТХ/Спецификация_ИТХ_v1.md) — точная спецификация чекпоинтов (Arweave/Solana/канал закрытий).
-- [sync-between-servers.md](./sync-between-servers.md) — живая межсерверная синхронизация блокчейна и доставка DM на единственный сервер получателя.
+- [`01_Common_Block_Format.md`](01_Common_Block_Format.md) — точный Frame v1, ANS-104, подпись, хэши и теги.
+- [`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) — история изменений протокола.
 
-## Важные ограничения MVP
-- Каналы `type=100` и `type=200` присутствуют в формате, но сейчас не используются в UI.
-- Поддерживаемый рабочий сценарий UI на текущем этапе: `stories (type=0)` и `public (type=1)`.
+## Короткая схема
 
-## Обязательное сопровождение
-- При любом изменении формата/правил блокчейна в коде документы этого каталога обновляются в том же наборе изменений.
-- Обычный `AddBlock` сейчас пишет через `<blockchainName>.tmp_bch`, `<blockchainName>.write_check` и `<blockchainName>.write_pending`; эта схема и `BlockchainTmpRecoveryOnStartup` должны быть описаны в актуальной документации по синхронизации и recovery.
-- Для runtime-агрегатов статистики `user_stats_state` и `channel_stats_state` действует тот же принцип derived state: они обновляются вместе с `AddBlock` и полностью пересобираются при full resync.
-- Если в старых данных есть канал владельца, которого ещё нет в `solana_user_pda_current`, сервер не падает: `channel_stats_state` всё равно обновляется, а `user_stats_state` создаётся только после появления пользователя в Solana PDA.
-- Каждое обновление документов фиксируется в `CHANGELOG.md` с датой/временем и хэшем коммита-основания.
+```text
+User
+  -> создаёт Frame v1
+  -> tags: App=test5590, при канале c=<slug>
+  -> Ed25519 подписывает ANS-104 deep-hash
+  -> готовый DataItem
+  -> AddBlock
+
+Server
+  -> verify DataItem + SHiNE chain
+  -> PostgreSQL
+  -> каждые ~15 минут ANS-104 bundle
+  -> Arweave L1
+
+Other servers
+  -> GraphQL App=test5590
+  -> скачивают/извлекают DataItem
+  -> verify
+  -> PostgreSQL без повторной публикации
+```
+
+## Важные свойства
+
+- SHiNE `prevHash` остаётся SHA-256 предыдущего Frame v1 и не зависит от Arweave.
+- `data_item_id` нужен для Arweave, поиска и дедупликации.
+- PostgreSQL — единственное локальное хранилище пользовательских блоков.
+- Тестовый namespace `App=test5590` специально отделён от будущего production namespace.

docs/Blockchain/sync-between-servers.md

@@ -1,280 +1,42 @@
-# Синхронизация блокчейнов и доставка DM между серверами SHiNE
+# Синхронизация blockchain между SHiNE-серверами
 
-Документ описывает архитектуру и протокол синхронизации данных между партнёрскими серверами SHiNE.
+## Локальная модель хранения
 
-## 1. Зачем нужна синхронизация
+PostgreSQL является единственным локальным хранилищем пользовательских блоков. Файлы `<blockchain>.bch`, `.tmp_bch`, `.write_pending`, `.write_check`, `.resync_pending` не используются.
 
-Пользователи SHiNE могут быть «приписаны» к разным серверам.
-Когда пользователь A (на сервере X) пишет пользователю B (на сервере Y):
+`blocks.block_bytes` хранит полный подписанный ANS-104 DataItem. `blockchain_state` хранит текущую вершину цепочки.
 
-1. Сервер X принимает сообщение;
-2. Сервер X должен переслать DM-блок серверу Y;
-3. Сервер Y сохраняет блок и доставляет в активные сессии пользователя B.
+## Обычный AddBlock
 
-Аналогично, блоки пользовательского блокчейна (записи `AddBlock`) должны синхронизироваться,
-чтобы любой партнёрский сервер мог отдать полную историю пользователя.
+Все проверки и запись выполняются под lock конкретной chain. После проверки Frame v1, подписи и `prevHash` одна SQL-транзакция записывает block + derived state + новую вершину.
 
-## 2. Список серверов синхронизации (`sync_servers`)
+Локально созданный пользовательский блок получает `arweave_publish_pending=true`.
 
-Каждый сервер регистрирует в своей Solana PDA список `sync_servers` —
-логины SHiNE-аккаунтов партнёрских серверов, с которыми он синхронизируется.
+## Периодический peer-to-peer sync
 
-`sync_servers` относится к серверному узлу и не является списком
-access-серверов обычного пользователя. У пользователя действует только первый
-`access_servers[0]`.
+Старый межсерверный P2P sync может получать `GetBlockchainBlock` и применять полученный полный DataItem через `AddBlock`. При divergence full-resync:
 
-- Список хранится в блоке `ServerProfileBlock` внутри `user_pda` сервера.
-- Адрес каждого партнёрского сервера читается из его PDA на Solana.
-- Синхронизация двусторонняя: оба сервера должны иметь друг друга в `sync_servers`.
+1. берёт lock chain;
+2. очищает derived rows/blocks/state через `BlockchainResyncCleanupDAO`;
+3. пересоздаёт state из актуального пользовательского реестра;
+4. последовательно проигрывает удалённую цепочку с блока 0;
+5. никаких файловых swap/recovery операций нет.
 
-## 3. Что синхронизируется
+## Arweave sync
 
-### 3.1 Личные сообщения (DM)
+Дополнительно каждый сервер может независимо включить `ArweaveBlockSyncScheduler`.
 
-- Все DM-блоки форматов типов `1/2` (текст) и `3/4` (read-receipt).
-- Сервер-отправитель: сохраняет пару и ставит асинхронную delivery-задачу.
-- Сервер-получатель: сохраняет входящий блок в `signed_messages`, затем доставляет его активным сессиям.
-- Дедупликация по уникальному `message_key = from|to|timeMs|nonce|type`.
-- Между access-серверами одного пользователя DM не реплицируются.
-- Полная актуальная схема: `docs/Personal_Messages/Доставка_и_синхронизация_DM.md`.
+Он ищет child DataItems по тестовому тегу `App=test5590`, проверяет их и импортирует через ту же бизнес-проверку AddBlock. Импортированные блоки не публикуются повторно.
 
-### 3.2 Блоки пользовательского блокчейна
+Если блоки обнаружены не по порядку, persistent queue оставляет более поздние блоки pending до появления предыдущих.
 
-- Все блоки `AddBlock` пользователей, зарегистрированных на сервере или синхронизирующихся через него.
-- Синхронизируются в обе стороны между всеми партнёрами из `sync_servers`.
-- Порядок блоков сохраняется (по глобальному номеру блока и хэшу).
-- Дедупликация по глобальному номеру блока и хэшу.
+## Источник истины для цепочки
 
-### 3.3 Пользовательские настройки
+Arweave не участвует в вычислении SHiNE chain hash:
 
-Пользовательские настройки хранятся локально на единственном access-сервере и
-между серверами не синхронизируются.
+```text
+block_hash = SHA256(FrameV1Bytes)
+next.prevHash32 = block_hash
+```
 
-## 4. Текущая реализованная схема
-
-На текущем этапе сервер уже умеет базовую межсерверную синхронизацию пользовательских блокчейнов.
-
-### 4.1 Что уже сделано
-
-1. При старте сервер читает свой `server.SHiNE.login`.
-2. По этому логину он загружает из Solana свою server PDA.
-3. Из неё вытаскивает список `sync_servers`.
-4. Для каждого логина партнёра сервер читает его PDA и сохраняет локально:
-   - `login`
-   - `server_address`
-5. После этого:
-   - новые локальные `AddBlock` рассылаются партнёрам в фоне;
-   - при старте запускается periodic sync;
-   - periodic sync повторяется каждые `12` часов после старта.
-
-### 4.2 Какие server-to-server API уже используются
-
-- `ListBlockchainHeads` — список heads всех локальных цепочек партнёра;
-- `GetBlockchainBlock` — чтение одного конкретного блока партнёра;
-- `GetSyncUserProfile` — минимальный профиль пользователя для локального создания runtime-проекции пользователя и `blockchain_state` без обращения в Solana RPC.
-
-### 4.3 Как сейчас работает periodic sync
-
-Для каждого сервера из локальной таблицы `sync_servers`:
-
-1. запрашивается `ListBlockchainHeads`;
-2. для каждой удалённой цепочки сравниваются:
-   - `lastBlockNumber`
-   - `lastBlockHash`
-   - локальное состояние;
-3. если локальная цепочка слабее, сервер по одному блоку вызывает `GetBlockchainBlock`;
-4. каждый скачанный блок локально применяется через существующий `AddBlock`;
-5. если у сервера ещё нет локальной записи пользователя/цепочки, перед этим подготавливается локальная runtime-проекция пользователя и `blockchain_state`.
-6. если во время replay обнаруживается рассинхрон или на одинаковой высоте удалённая цепочка сильнее, запускается полный resync:
-   - цепочка помечается in-memory как `resync in progress`;
-   - создаётся marker-file в `data/`;
-   - в одной SQL-транзакции очищаются локальные данные цепочки и корректируются чужие счётчики;
-   - удаляются `.bch` и `.tmp_bch`;
-   - цепочка подтягивается заново с `0` через `GetBlockchainBlock`.
-   - обычный `AddBlock` на эту цепочку в этот момент возвращает `chain_resync_in_progress`.
-
-### 4.4 Как именно работает full resync
-
-Full resync запускается только тогда, когда:
-
-- локальная chain отстаёт и обычная докачка хвоста упирается в `bad_prev_hash` или `bad_block_number`;
-- либо высота цепочек одинаковая, но удалённая версия сильнее по правилу:
-  - `lastBlockNumber`;
-  - `fileSizeBytes`;
-  - `lastBlockHash`.
-
-Порядок действий:
-
-1. Ставится in-memory guard на `blockchainName`.
-2. Создаётся marker-file `<blockchainName>.resync_pending`.
-3. Обычный `AddBlock` на эту chain временно получает `chain_resync_in_progress`.
-4. Вызывается атомарный SQL cleanup одной chain:
-   - уменьшаются чужие `likes_count` и `replies_count`;
-   - удаляются локальные derived-state записи этой chain;
-   - удаляются `blocks` и `blockchain_state` этой chain.
-5. Удаляются файлы `<blockchainName>.bch` и `<blockchainName>.tmp_bch`.
-6. Локальная chain создаётся заново через `GetSyncUserProfile` или через Solana import, если `sync.importUserProfileFromPartner.enabled=false`.
-7. Chain replay-ится с `0` через `GetBlockchainBlock`.
-8. Если всё прошло успешно, marker-file удаляется.
-9. Если на любом шаге произошёл сбой, marker-file остаётся на диске, и сервер добивает эту chain при следующем старте.
-
-Важно:
-
-- full resync не делает умный rollback по одному блоку;
-- full resync не трогает DM-таблицы и current users слой;
-- висячие cross-chain ссылки считаются допустимым поведением системы.
-
-### 4.5 Как работает обычный `AddBlock` и его recovery
-
-Обычная запись блока теперь тоже идёт через временные артефакты:
-
-1. собирается `<blockchainName>.tmp_bch` как полный кандидат на замену основного файла;
-2. пишется маленький sidecar `<blockchainName>.write_check` с `blockNumber` и `blockHash`;
-3. только после этого создаётся пустой marker `<blockchainName>.write_pending`;
-4. выполняется SQL-транзакция;
-5. после `commit` tmp атомарно ставится на место основного `.bch`;
-6. marker и sidecar удаляются.
-
-На старте `BlockchainTmpRecoveryOnStartup` смотрит именно на эту пару:
-
-- если `write_pending` есть, recovery проверяет sidecar и БД, а затем либо завершает swap, либо чистит временные файлы;
-- если `write_pending` нет, а `tmp_bch` или `write_check` остались, это мусор и он удаляется;
-- `resync_pending` сюда не относится, это отдельный recovery-поток.
-
-### 4.6 Startup recovery по marker-file
-
-При старте сервер идёт в таком порядке:
-
-1. `BlockchainTmpRecoveryOnStartup` для `*.write_pending` и orphan `*.tmp_bch` / `*.write_check`;
-2. `BlockchainResyncRecoveryOnStartup` для `*.resync_pending`;
-3. только потом поднимается обычный сервер и запускается `PeriodicBlockchainSyncService`.
-
-Если marker-file существует:
-
-- сервер не должен начинать обычную работу поверх этой chain;
-- recovery снова выполняет cleanup и replay с нуля;
-- если recovery не завершился, marker остаётся, и сервер не переходит к обычному режиму для этой chain.
-
-### 4.7 Зачем понадобился `GetSyncUserProfile`
-
-Изначально подготовка локальной цепочки делалась через Solana:
-
-- из `blockchainName` извлекался `login`;
-- сервер вызывал import пользователя из Solana PDA;
-- по данным PDA локально создавались runtime-проекция пользователя и `blockchain_state`.
-
-На практике это упёрлось в ограничение внешнего Solana RPC: при чистом старте и массовой подтяжке чужих цепочек сервер мог получать `HTTP 429`.
-
-Поэтому добавлен отдельный обходной режим:
-
-- настройка `sync.importUserProfileFromPartner.enabled=true`
-- в этом режиме сервер **не ходит в Solana RPC** для создания локальной цепочки во время sync;
-- вместо этого он запрашивает у сервера-партнёра `GetSyncUserProfile` и создаёт локальную запись по данным партнёра.
-- если локальная runtime-проекция пользователя уже существует, sync восстанавливает только `blockchain_state` и не трогает user-layer.
-
-Это временная практическая заплатка, чтобы clean-start sync не зависел от rate limit внешнего Solana endpoint.
-
-### 4.8 Что делает настройка `sync.importUserProfileFromPartner.enabled`
-
-- `false` — стандартный режим, подготовка локального пользователя идёт через Solana PDA;
-- `true` — sync-режим обхода Solana, локальный пользователь создаётся по server-to-server `GetSyncUserProfile`.
-
-Настройка влияет именно на этап подготовки отсутствующей локальной цепочки во время periodic sync.
-
-## 5. Реализованный постоянный server-to-server транспорт
-
-Этот раздел не меняет текущую семантику DM, settings и blockchain. Он описывает
-единый постоянный WSS-транспорт, через который выполняются уже существующие операции.
-
-### 5.1 Межсерверное соединение
-
-- Серверы устанавливают постоянное исходящее WebSocket-соединение друг с другом.
-- Адрес партнёра определяется по `server_address` из его Solana PDA.
-- После подключения отправляется `ServerHello` с `serverLogin`, версией протокола и capabilities.
-- На текущем этапе `serverLogin` принимается на доверии; подпись Ed25519 корневым ключом сервера отложена.
-- При разрыве выполняется переподключение с jitter/backoff до 60 секунд.
-- После 120 секунд отсутствия полезного трафика отправляется WebSocket ping; pong ожидается 15 секунд.
-- Один физический канал переиспользуют доставка DM и blockchain.
-
-### 5.2 Доставка новых данных (push)
-
-- При получении нового блока сервер может немедленно пушить его всем подключённым партнёрам.
-- Партнёр подтверждает приём (ACK). Без ACK — повтор с backoff.
-- DM использует отдельное расписание, описанное в `docs/Personal_Messages/Доставка_и_синхронизация_DM.md`.
-
-### 5.3 Начальная синхронизация (backfill)
-
-- При первом подключении к партнёру серверы могут обмениваться курсорами состояния блокчейнов.
-- Сервер с более полной историей досылает недостающее партнёру.
-- DM-history backfill между access-серверами отсутствует.
-
-### 5.4 Разрешение конфликтов
-
-- Блоки пользовательского блокчейна: порядок определяется глобальным номером блока.
-  Конфликтующие ветки (fork) разрешаются по правилам `AddBlock` (см. `docs/Blockchain/README.md`).
-- DM: конфликтов нет, `message_key` уникален.
-
-## 6. Маршрутизация DM между серверами
-
-При отправке DM от пользователя A к пользователю B:
-
-1. Клиент A отправляет пару блоков на свой сервер X.
-2. Сервер X валидирует и локально сохраняет пару.
-3. До ответа клиенту X отправляет входящую копию на единственный
-   `access_servers[0]` пользователя B через `ReceiveIncomingMessage`.
-4. Успешное сохранение на сервере B означает терминальный `delivered`.
-5. При неудаче выполняются повторы через 30 секунд, 5 минут, 25 минут и 1 час.
-6. После неудачной попытки через час ставится терминальный `failed`.
-
-Изменения routing B учитываются до терминального состояния, потому что список маршрутов перечитывается на каждой попытке.
-
-## 7. Безопасность
-
-- Все блоки подписаны ключами пользователя на клиенте — сервер не может подделать содержимое.
-- Серверы не расшифровывают DM-контент; E2EE уже выполняется клиентами.
-- При синхронизации каждый блок проходит валидацию подписи на принимающем сервере.
-- Межсерверная авторизация DM-операций пока отложена; `sourceServerLogin` временно считается доверенным.
-
-## 8. Статус реализации
-
-| Компонент | Статус |
-|-----------|--------|
-| Регистрация серверной PDA в Solana | ✅ Реализовано |
-| Чтение `sync_servers` из PDA | ✅ Реализовано |
-| Локальная таблица `sync_servers` | ✅ Реализовано |
-| Публичный `ListBlockchainHeads` | ✅ Реализовано |
-| Публичный `GetBlockchainBlock` | ✅ Реализовано |
-| Публичный `GetSyncUserProfile` | ✅ Реализовано |
-| Плановый blockchain sync при старте + каждые 12 часов | ✅ Реализовано |
-| Обход Solana RPC через `sync.importUserProfileFromPartner.enabled` | ✅ Реализовано |
-| Обычный `AddBlock` через `tmp_bch`/`write_check`/`write_pending` | ✅ Реализовано |
-| Межсерверный постоянный WebSocket-канал | ✅ Реализован общий `ServerConnectionPool` |
-| Асинхронная доставка DM на единственный access-сервер получателя | ✅ Реализовано |
-| Retry DM до 1 часа + UI-state | ✅ Реализовано |
-| Репликация DM и настроек между access-серверами | Не используется |
-| Push блоков блокчейна партнёрам | ✅ Выполняется через постоянный WSS-пул |
-| Periodic backfill отсутствующего хвоста | ✅ Реализовано |
-| Разрешение рассинхрона / divergence | ✅ Реализована базовая full-resync схема во время periodic sync |
-| Startup recovery по `*.resync_pending` marker-file | ✅ Реализовано |
-| Маршрутизация DM только через `access_servers[0]` | ✅ Реализовано |
-| Криптографическая server-to-server авторизация DM | Нужна реализация |
-
-Текущая версия сервера использует постоянный WSS-пул для существующих
-server-to-server JSON-операций. Отдельной будущей задачей остаётся
-криптографическая авторизация server-to-server вызовов.
-
-Следующие отдельные шаги после текущего этапа:
-- отдельно проверить full-resync и startup-recovery на реальном тестовом прогоне после ручного удаления БД/файлов.
-
-### 8.1 Практическая проверка на тестовом сервере
-
-Проверка на `server2.shineup.me` показала, что текущая схема действительно поднимает цепочку при старте:
-
-- после рестарта сервер сначала проходит `BlockchainTmpRecovery`;
-- затем обрабатывает `BlockchainResyncRecovery`;
-- после этого сам догружает цепочку `aidartest-001` с `shineup.me`;
-- итоговое состояние на тестовом сервере:
-  - `blockchain_state.last_block_number = 13`
-  - `blocks` по `aidartest-001` = `14` записей
-
-Это подтверждает, что startup sync и full-resync flow работают в живом сценарии, а не только в коде.
+Поэтому цепочка остаётся проверяемой и переносимой независимо от конкретного storage backend.

docs/Personal_Messages/README.md

@@ -9,6 +9,8 @@
 - `docs/Personal_Messages/Доставка_и_синхронизация_DM.md` — доставка на
   единственный access-сервер, retry-воркер и UI-статусы
 - `docs/Personal_Messages/Технические_вставки_DM_v1.md` — формат специальных `<S:...>` вставок внутри plaintext DM после расшифровки
+- `docs/Personal_Messages/Файлы_DM_v2.md` — большие chunked-вложения, голосовые и BitTorrent v2 SHA-256/Merkle metadata
+- `docs/API/18_DM_File_Storage_API.md` — HTTP-хранилище зашифрованных файлов DM на access-сервере отправителя
 
 Исторический устаревший документ сохранён отдельно:
 
@@ -19,3 +21,15 @@
 - код DM и оба документа `Протокол_DM_v1.md` + `Формат_DM_v1.md` всегда должны обновляться синхронно;
 - если меняется поведение DM в коде, в том же наборе изменений обновляется и эта документация.
 - локальная таблица пользователей для DM считается кэшем, а источником истины остаётся Solana PDA; если серверная логика DM меняет правила lazy-import пользователей из PDA, это тоже обязательно фиксируется в документации.
+
+## Зашифрованные файлы DM
+
+Официальный UI v1 умеет отправлять файл как внешний зашифрованный объект:
+
+- файл шифруется в браузере `AES-256-GCM`;
+- ciphertext хранится только на access-сервере отправителя под именем `Base58(SHA-256(ciphertext))`;
+- AES-key, IV, исходное имя, MIME, размер и URL находятся в `<S:file...>` внутри plaintext DM, а значит сами защищены существующим E2EE DM;
+- получатель скачивает ciphertext с сервера отправителя, проверяет SHA-256, расшифровывает локально и только затем отдаёт Blob браузеру для сохранения под исходным именем;
+- сервер файлов ключ расшифрования не получает.
+
+Формат бинарного контейнера `SHiNE_DM` при этом не меняется.

docs/Personal_Messages/Протокол_DM_v1.md

@@ -131,6 +131,12 @@ dm_dialog_state хранит:
 WebSocket push ускоряет отображение, но после переподключения клиент запрашивает
 историю у своего единственного access-сервера.
 
+UI-правило для открытого диалога: разделитель «Новые сообщения» относится только к
+непрочитанным сообщениям, которые уже существовали до открытия экрана чата. Если новое
+входящее сообщение приходит, пока этот диалог уже открыт, клиент просто добавляет его в
+текущий поток, не создавая новый разделитель «Новые сообщения»; затем обычный механизм
+видимого чтения/receipt отмечает его прочитанным.
+
 ## 9. Подтверждения прочтения
 
 Read-receipt создаётся как подписанная пара type=3/type=4 и проходит тот же
@@ -222,3 +228,38 @@ DeleteMessage принимает type=5/6. DeleteConversation принимает
 - при удалении чата с `friend`/`close_friend` UI должен отдельно предупредить, что одна очистка истории не уберёт строку чата, и при подтверждении снять социальную связь и очистить историю.
 
 Это правило не меняет wire/API-формат DM и не меняет байтовый формат tombstone.
+
+
+## 15. Файлы в личных сообщениях
+
+Файл не встраивается байтами в `SHiNE_DM`. До отправки DM официальный браузерный клиент:
+
+1. генерирует отдельные случайные `AES-256-GCM` key и IV;
+2. шифрует исходный файл локально;
+3. вычисляет `fileId = Base58(SHA-256(ciphertext))`;
+4. подписанным HTTP `PUT` загружает ciphertext на свой текущий access-сервер;
+5. отправляет обычный контентный DM `type=1/2`, plaintext которого начинается с `<S:file...>`.
+
+Внутри `<S:file...>` находятся `fileId`, абсолютный URL сервера отправителя, AES-key/IV и исходная метаинформация файла. Так как весь plaintext контентного DM уже шифруется на ключ получателя/отправителя, сервер не получает ключ файла.
+
+Получатель после E2EE-расшифровки DM скачивает ciphertext непосредственно с указанного access-сервера отправителя, сверяет `SHA-256`, расшифровывает файл в браузере и сохраняет исходный файл.
+
+Отключение функции «Передача файлов» в локальных дополнительных настройках запрещает только отправку новых файлов; ранее полученные `<S:file...>` остаются скачиваемыми.
+
+Хранение ciphertext и HTTP-контракт описаны в `docs/API/18_DM_File_Storage_API.md`.
+
+## 16. Дедупликация файлов и пересылка сообщений (2026-09-11)
+
+Для HTTP-хранилища DM-файлов действует усиленное правило content-addressed хранения:
+
+- перед загрузкой каждого ciphertext-объекта официальный UI делает `HEAD /dm-files/{fileId}`;
+- если сервер подтверждает объект с тем же `fileId` и размером, `PUT` с байтами повторно не выполняется;
+- сервер перед ответом на `HEAD`, `GET` и перед `alreadyExists=true` сам пересчитывает `SHA-256` сохранённого объекта и сверяет его с `fileId`;
+- повреждённый или подменённый объект не считается существующим и не выдаётся клиенту; при следующем корректном `PUT` он может быть записан заново.
+
+Пересылка личного сообщения не вводит новый тип DM и не добавляет признак «переслано». UI создаёт обычное новое контентное сообщение `type=1/2` выбранному собеседнику:
+
+- для обычного текста переносится отображаемый текст сообщения;
+- исходный `<S:reply...>` не переносится, поэтому новое сообщение не остаётся ответом на сообщение из старого чата;
+- для сообщения с файлами повторно используются существующие `<S:file...>`-описатели, поэтому ciphertext не шифруется и не загружается повторно;
+- сервер и получатель видят пересланное сообщение как обычное новое сообщение без служебной пометки об источнике.

docs/Personal_Messages/Технические_вставки_DM_v1.md

@@ -68,7 +68,7 @@
 - `kind` — ASCII-идентификатор типа вставки;
 - параметры отделяются `;`;
 - ключ и значение отделяются `=`;
-- значения не экранируются в v1;
+- значения обычных v1-вставок не экранируются; для `file` поля `url`, `name`, `mime` кодируются через percent-encoding (`encodeURIComponent`), чтобы `;`, `=` и `>` внутри метаданных не ломали блок;
 - канонический новый префикс: `<S:`;
 - legacy-префикс `<SHiNE:` продолжает поддерживаться при чтении.
 
@@ -127,7 +127,32 @@ fromLogin|toLogin|timeMs|nonce
 - UI может рисовать такие сообщения отдельным специальным стилем.
 - официальный UI не отправляет call-summary, если от старта исходящего звонка до его завершения прошло меньше `5` секунд.
 
-## 7. Поведение официального UI
+## 7. Тип `file`
+
+Формат v1:
+
+```text
+<S:file;v=1;id=BASE58_SHA256;url=ENCODED_URL;key=BASE64URL_AES_KEY;iv=BASE64URL_IV;name=ENCODED_NAME;mime=ENCODED_MIME;size=123;encsize=139>📎 example.pdf
+```
+
+Поля:
+
+- `id` — `Base58(SHA-256(ciphertext))`;
+- `url` — абсолютный URL ciphertext на access-сервере отправителя, percent-encoded;
+- `key` — случайный 32-byte AES-256 key в Base64URL;
+- `iv` — случайный 12-byte AES-GCM IV в Base64URL;
+- `name` — исходное безопасно нормализованное имя файла, percent-encoded;
+- `mime` — исходный MIME, percent-encoded;
+- `size` — размер plaintext в байтах;
+- `encsize` — размер ciphertext в байтах.
+
+`key`, `iv` и метаданные безопасно находятся здесь только потому, что весь plaintext DM затем шифруется существующим E2EE-механизмом. Они не передаются файловому HTTP endpoint отдельно.
+
+Текст `📎 example.pdf` после блока служит fallback для старого клиента. Новый официальный UI вместо него рисует карточку файла и кнопку «Скачать».
+
+Перед локальной AES-GCM-расшифровкой клиент обязан повторно вычислить SHA-256 скачанного ciphertext и сравнить Base58 с `id`.
+
+## 8. Поведение официального UI
 
 Официальный UI SHiNE в v1:
 
@@ -137,12 +162,36 @@ fromLogin|toLogin|timeMs|nonce
   - `Звонок: H:MM:SS`
   - `Звонил, но недозвонился: ...`
 - для `reply` скрывает сам блок и показывает только текст ответа;
+- для `file` скрывает fallback-текст и показывает карточку вложения с локальным download/decrypt;
 - если исходное reply-сообщение не найдено, reply-preview не показывается.
 
-## 8. Совместимость
+## 9. Совместимость
 
 Так как это часть plaintext, а не часть серверного envelope:
 
 - сервер не обязан понимать этот формат;
 - будущие клиенты могут добавлять новые `kind`;
 - клиенты, которые распознают SHiNE-вставки, должны скрывать неизвестные блоки целиком, если они стоят в начале и корректно закрыты.
+
+## 10. Расширение `file` v2
+
+Клиент обязан продолжать читать `v=1`. Новые chunked-вложения отправляются так:
+
+```text
+<S:file;v=2;id=ROOT_MANIFEST_ID;url=ENCODED_URL;key=BASE64URL_AES_KEY;ivp=BASE64URL_4BYTE_PREFIX;name=ENCODED_NAME;mime=ENCODED_MIME;size=123;encsize=456;chunk=1048576;chunks=7;th=TORRENT_V2_INFOHASH;pr=TORRENT_V2_PIECES_ROOT;kind=file;dur=0>
+```
+
+Дополнительные поля v2:
+
+- `id` / `url` указывают не на весь файл, а на зашифрованный root manifest;
+- `ivp` — случайный 4-byte IV prefix, из которого детерминированно строятся уникальные IV chunks/pages/root;
+- `chunk` — plaintext chunk size, сейчас `1048576`;
+- `chunks` — число частей;
+- `th` — BitTorrent v2 SHA-256 infohash;
+- `pr` — BitTorrent v2 pieces root;
+- `kind=file|voice`;
+- `dur` — длительность voice в миллисекундах, для обычного файла `0`.
+
+В одном plaintext DM разрешено несколько последовательных `<S:file...>` блоков. Официальный UI собирает их в один список вложений и скрывает fallback-текст.
+
+Подробный формат chunk encryption, manifest pages и BitTorrent v2 hashing: `Файлы_DM_v2.md`.

docs/Personal_Messages/Файлы_DM_v2.md

@@ -0,0 +1,124 @@
+# Файлы и голосовые DM v2: chunked AES-GCM + BitTorrent v2 hashes
+
+## Цели
+
+DM file v2 убирает ограничение размера исходного файла, не требует держать файл целиком в RAM и сохраняет серверную модель «сервер видит только ciphertext».
+
+Основные свойства:
+
+- plaintext режется на куски по `1 MiB`;
+- каждый кусок независимо шифруется `AES-256-GCM` одним случайным ключом файла, но с уникальным 96-bit IV;
+- каждый ciphertext-кусок хранится как immutable объект `Base58(SHA-256(ciphertext))`;
+- список кусков хранится в зашифрованных страницах манифеста по 256 записей;
+- корневой манифест тоже зашифрован и content-addressed;
+- E2EE DM содержит только ссылку на корневой манифест, AES-key, IV-prefix и пользовательские метаданные;
+- один DM может содержать до 10 `<S:file;v=2...>` блоков;
+- `kind=voice` использует тот же формат хранения и отдельный UI проигрывателя.
+
+## IV и domain separation
+
+На один файл создаётся случайный 4-byte `ivPrefix`.
+
+12-byte IV строится как:
+
+```text
+ivPrefix[4] || uint64_be(token)
+```
+
+Диапазоны `token` разделены:
+
+- chunks: `0 .. 2^63-1`;
+- manifest pages: `2^63 + pageIndex`;
+- root manifest: `0xffffffffffffffff`.
+
+AAD также содержит домен (`chunk`, `page`, `root`), prefix и индекс. Поэтому перестановка ciphertext-кусков не проходит AES-GCM authentication.
+
+## Manifest pages
+
+Каждая страница после расшифровки содержит до 256 записей:
+
+```json
+{
+  "v": 2,
+  "page": 0,
+  "chunks": [
+    {
+      "i": 0,
+      "id": "Base58(SHA-256(ciphertext))",
+      "ps": 1048576,
+      "es": 1048592,
+      "ph": "BitTorrent-v2-piece-hash-base64url"
+    }
+  ]
+}
+```
+
+Страницы сами AES-GCM зашифрованы и загружаются в `/dm-files/{id}`.
+
+## Root manifest
+
+После расшифровки:
+
+```json
+{
+  "v": 2,
+  "scheme": "SHINE-DM-CHUNKED-AES-256-GCM",
+  "chunkSize": 1048576,
+  "fileSize": 123456789,
+  "chunkCount": 118,
+  "pages": [{"id":"...","count":118,"encryptedSize":12345}],
+  "torrent": {
+    "metaVersion": 2,
+    "blockLength": 16384,
+    "pieceLength": 1048576,
+    "piecesRoot": "...",
+    "infoHash": "..."
+  }
+}
+```
+
+Имя файла и MIME в manifest не пишутся. Они остаются внутри E2EE DM.
+
+## BitTorrent v2 совместимость
+
+Хеширование соответствует BEP 52:
+
+- базовый hash block: `16 KiB`;
+- SHA-256;
+- piece length: `1 MiB`;
+- Merkle padding leaf = 32 zero bytes;
+- `pieces root` вычисляется по правилам BitTorrent v2;
+- `infoHash` = `SHA-256(bencode(info dictionary))`;
+- piece-layer hash каждого 1-MiB куска хранится в зашифрованной manifest page.
+
+Из `name`, `size`, `piecesRoot` и списка `ph` можно построить tracker-less `.torrent` v2 без повторного хеширования исходного файла.
+
+Это совместимость метаданных и проверки контента. HTTP `/dm-files` пока не является BitTorrent peer transport: для настоящего P2P потребуется отдельный seeding/peer слой.
+
+## Скачивание
+
+Получатель:
+
+1. получает и проверяет ciphertext root manifest по Base58(SHA-256);
+2. расшифровывает root manifest;
+3. по очереди получает manifest pages;
+4. получает каждый chunk с сервера отправителя;
+5. проверяет content address ciphertext;
+6. расшифровывает chunk локально;
+7. проверяет BitTorrent-v2 piece hash;
+8. пишет plaintext на диск;
+9. в конце проверяет итоговый `pieces root`.
+
+В браузерах с File System Access API plaintext пишется на диск по частям и целиком в RAM не собирается. В остальных браузерах остаётся Blob fallback без искусственного лимита размера, но фактический предел зависит от памяти браузера.
+
+## Голосовые
+
+`MediaRecorder` пишет `Opus/WebM`, `Opus/Ogg` или поддерживаемый браузером audio MIME. После завершения запись проходит тот же DM file v2 pipeline.
+
+Технический блок отличается полями:
+
+```text
+kind=voice;dur=<milliseconds>
+```
+
+Получатель видит player с Play/Pause, прогрессом и длительностью. Аудио расшифровывается только на клиенте.

docs/Personal_Messages/Формат_DM_v1.md

@@ -264,6 +264,12 @@ ReadReceiptBody_v1_0
 - если подтверждение прочтения приходит в другом порядке, сервер сохраняет максимальный watermark и не откатывает счётчик назад.
 - в списке диалогов сервер может отдавать последний signed block как `lastMessageBlobB64` без попытки извлечь plaintext preview.
 
+
+UI-примечание (байтовый формат не меняет): разделитель «Новые сообщения» создаётся только
+для непрочитанного хвоста, который существовал до открытия диалога. Входящий `type=1`,
+полученный при уже открытом соответствующем чате, отображается сразу без создания нового
+разделителя; это не изменяет signed-контейнер и не вводит нового поля протокола.
+
 ## 9. Контент типов `5/6`
 
 Типы:
@@ -365,3 +371,25 @@ ReadReceiptBody_v1_0
 Контейнер `type=7/8` является служебным tombstone очистки истории. Его наличие без обычных сообщений `type=1/2` не должно само по себе означать, что у пары есть видимый пользовательский диалог.
 
 Следствие для UI/агрегата диалогов: `hasDialog` определяется наличием пользовательского содержимого (или непрочитанных пользовательских сообщений), а не наличием служебной записи состояния/tombstone. Формат контейнера при этом не изменяется.
+
+
+## 15. Вложения `<S:file>` и бинарный формат
+
+Поддержка файлов не добавляет полей в `SHiNE_DM` и не меняет порядок существующих полей.
+
+Для контентных `type=1/2` технический блок `<S:file...>` является частью обычного plaintext, который затем попадает в уже существующий зашифрованный `body`. Сам ciphertext внешнего файла в `SHiNE_DM` не включается.
+
+Поэтому подписи контейнера, `baseKey`, `revisionTimeMs`, `reencryptedAtMs`, алгоритм E2EE DM и правила парности входящей/исходящей копий остаются прежними.
+
+## 16. Примечание о пересылке сообщений (2026-09-11)
+
+Пересылка не меняет байтовый формат `SHiNE_DM` и не добавляет отдельный `messageType` или флаг forward/repost.
+
+Клиент формирует новый обычный plaintext для `type=1/2`:
+
+- текстовая часть копируется как новое сообщение;
+- `<S:reply...>` исходного сообщения удаляется;
+- валидные `<S:file...>` могут быть скопированы без изменения, чтобы новое сообщение ссылалось на тот же уже загруженный зашифрованный объект;
+- информация о том, из какого чата или сообщения выполнена пересылка, в контейнер не добавляется.
+
+Таким образом подпись, `baseKey`, шифрование и структура контейнера остаются полностью прежними: меняется только содержимое нового plaintext перед стандартной отправкой.

docs/Solana/user_pda/README.md

@@ -94,16 +94,17 @@ UserPdaRecordV1
 | `40` | `AccessServersBlock` | Серверы доступа/relay. |
 | `50` | `SessionsBlock` | Опубликованные пользовательские сессии и homeserver-ы. |
 | `70` | `TrustedStateBlock` | Счетчик trusted-связей. |
+| `100` | `ArchiveHeadBlock` | Legacy/reserved. Новый per-block ANS-104 transport не использует это поле для пользовательской истории. |
 | `255` | `ReservedBlock` | Зарезервировано, пока не используется. |
 
 Правила:
 
 - неизвестный `block_type` в `format_major = 1` считается ошибкой;
 - обязательные блоки: `RecoveryKeyBlock`, `RootKeyBlock`, `ClientKeyBlock`, `BlockchainRegistryBlock`;
-- необязательные блоки: `ServerProfileBlock`, `AccessServersBlock`, `SessionsBlock`, `TrustedStateBlock`;
+- необязательные блоки: `ServerProfileBlock`, `AccessServersBlock`, `SessionsBlock`, `TrustedStateBlock`, `ArchiveHeadBlock`;
 - каждый обязательный блок должен встречаться ровно один раз;
 - порядок блоков в записи фиксируется для простоты проверки:
-  `RecoveryKey`, `RootKey`, `ClientKey`, `BlockchainRegistry`, `ServerProfile`, `AccessServers`, `Sessions`, `TrustedState`.
+  `RecoveryKey`, `RootKey`, `ClientKey`, `BlockchainRegistry`, `ServerProfile`, `AccessServers`, `Sessions`, `TrustedState`, `ArchiveHead`.
 
 ## 6. RecoveryKeyBlock
 
@@ -359,6 +360,28 @@ TrustedStateBlock
 
 Пока блок с доверенными лицами не реализуется, потому что полный формат trusted-логики еще не составлен. В будущем trusted-связи, очереди, таймеры и подтверждения должны быть вынесены в отдельный формат.
 
+## 15.1. ArchiveHeadBlock
+
+Необязательный блок текущей головы серверного архива. Он используется archive-capable сервером и хранится в том же User PDA.
+
+```text
+ArchiveHeadBlock
+- block_type: u8 = 100
+- block_version: u8 = 0
+- archive_tx_id: [u8; 32]
+- archive_hash: [u8; 32]
+```
+
+Семантика:
+
+- `archive_tx_id` — legacy/reserved поле старой archive-head схемы; новый per-block ANS-104 transport его не обновляет;
+- `archive_hash` — SHA-256 большого archive block по правилам `docs/Archive/01_PROTOCOL_v1.0.md`;
+- отсутствие block `100` означает, что аккаунт ещё не объявлял archive head;
+- обычный legacy `update_user_pda`, в instruction которого archive extension отсутствует, **обязан сохранить существующий ArchiveHeadBlock без изменений**;
+- расширенный `update_user_pda` может заменить archive head или явно очистить его; отдельной Solana instruction для архива нет.
+
+`ArchiveHeadBlock` входит в unsigned bytes User PDA и тем самым покрывается обычной root-подписью записи.
+
 ## 16. Подпись user_pda
 
 Подписывается не вся PDA целиком, а unsigned-часть записи:
@@ -392,6 +415,7 @@ Solana-программа проверяет подпись через встр
 - обязательные блоки присутствуют;
 - создается минимум один `BlockchainRecord`;
 - новый `SessionsBlock` может присутствовать, но при обычной регистрации сейчас записывается пустой список с `sessions_mode = 1`;
+- `ArchiveHeadBlock` при регистрации не обязателен; обычный пользователь/сервер может начать публиковать архив позже;
 - стартовый `paid_limit_bytes` равен стартовому бонусу плюс оплаченный дополнительный лимит;
 - `used_bytes <= paid_limit_bytes`;
 - пользователь платит регистрационную комиссию;
@@ -408,6 +432,7 @@ Solana-программа проверяет подпись через встр
 - `prev_record_hash` равен хэшу unsigned-части предыдущей записи;
 - `updated_at_ms` обновляется;
 - unsigned-часть новой записи подписана `root_key`;
+- если archive extension в instruction отсутствует (legacy client), старый `ArchiveHeadBlock` сохраняется; если extension присутствует, применяется переданное `archive_head_update`;
 - лимиты блокчейнов могут только увеличиваться;
 - занятый размер и номер последнего блока не могут уменьшаться;
 - при увеличении оплаченного лимита пользователь доплачивает комиссию;

docs/Solana_Architecture/details/shine_users.md

@@ -135,3 +135,23 @@
 - economy-настройки меняет DAO-authority;
 - upgrade-authority программы после проверки передается DAO;
 - пользовательские операции `create_user_pda` и `update_user_pda` остаются доступными обычным пользователям при корректных подписях и оплате.
+
+## ArchiveHeadBlock (legacy/reserved)
+
+Формат User PDA поддерживает необязательный `ArchiveHeadBlock` (`block_type = 100`, `block_version = 0`):
+
+```text
+archive_tx_id [32]
+archive_hash  [32]
+```
+
+Поле `ArchiveHeadBlock` осталось в Solana/PDA как legacy/reserved для совместимости формата PDA. Новый transport пользовательских блоков не использует server-level SHINE-ARCHIVE или archive head: каждый пользовательский block публикуется как ANS-104 DataItem внутри стандартных bundles.
+
+Отдельной инструкции программы для архива нет. Используется существующий `update_user_pda`. Парсер update instruction обратно совместим:
+
+- legacy payload без archive extension сохраняет старый block `100`;
+- новый payload может заменить/очистить archive head;
+- итоговая полная User PDA запись, включая block `100`, покрывается обычной root-подписью.
+
+Это позволяет обычным старым клиентским обновлениям профиля не стирать archive head серверного publisher-а.
+

docs/libs/shine-server-blockchain/Doc.md

@@ -1,4 +1,4 @@
-shine-server-blockchain — это библиотека, которая задаёт формат блока, правила парсинга/валидации тела, крипто-проверку (hash+Ed25519) и безопасную работу с файлами блокчейна (data/<name>.bch через временный .tmp_bch).
+shine-server-blockchain задаёт Frame v1, ANS-104 DataItem, правила парсинга/валидации body и криптографическую проверку. Пользовательские chain-файлы на диске больше не используются; полные DataItems хранятся в PostgreSQL.
 
 Как устроена структура и логика работы
 
@@ -33,7 +33,6 @@ BchCryptoVerifier отвечает за “как получить хэш и к
 4) Утилиты вокруг имени и файлов
 
 BlockchainNameUtil — извлекает login из blockchainName (отрезает 3 символа суффикса).
-FileStoreUtil — безопасное файловое хранилище:
 
 
 5) Объяснение структуры работы

docs/закомментировано/Личный_дневник.md

@@ -0,0 +1,68 @@
+# Личный дневник — временно отключён в UI
+
+Статус: **закомментировано / скрыто из интерфейса**.
+
+Личный дневник SHiNE не удалён из протокола и серверной части. На текущем этапе он только перестал отображаться пользователю в списке каналов.
+
+## Что это за функция
+
+«Дневник» — виртуальный персональный канал пользователя. Он формируется не как обычный канал с отдельной цепочкой постов, а собирается сервером из `STATUS_ACTION` записей пользователя.
+
+Основной read API:
+
+- `GetPersonalDiary`
+
+Связанная документация:
+
+- `docs/API/06_Channels_Read_API.md` — раздел `GetPersonalDiary`;
+- `docs/API/09_Operations_Index.md` — операция `GetPersonalDiary`;
+- `docs/Blockchain/15_STATUS_ACTION_Blocks.md` — действия, из которых собирается дневник;
+- `docs/Blockchain/CHANGELOG.md` — история добавления функции.
+
+## Что отключено сейчас
+
+В `shine-UI/js/pages/channels-list.js` отключён запрос `authService.getPersonalDiary(...)` при построении списка каналов.
+
+Код оставлен рядом в комментариях, а в `mapApiFeed(...)` передаётся `diaryPayload = null`. Благодаря этому карточка «Дневник» не появляется в разделе каналов.
+
+## Что намеренно НЕ удалено
+
+Чтобы не ломать обратную совместимость и сохранить возможность вернуть функцию позже, оставлены:
+
+- серверная операция `GetPersonalDiary`;
+- `authService.getPersonalDiary(...)`;
+- обработка diary-route в `channel-view.js`;
+- форматы `STATUS_ACTION`;
+- чтение старых типов сообщений и действий.
+
+То есть функция сохранена технически, но скрыта из обычной навигации.
+
+## Как вернуть дневник
+
+В `shine-UI/js/pages/channels-list.js` вернуть получение `diaryPayload`:
+
+```js
+let diaryPayload = null;
+try {
+  diaryPayload = await authService.getPersonalDiary(state.session.login, 200, 'asc');
+} catch {
+  diaryPayload = null;
+}
+```
+
+и убрать временное:
+
+```js
+const diaryPayload = null;
+```
+
+После этого `mapApiFeed(...)` снова сможет добавить виртуальную карточку дневника в список каналов.
+
+## Связанные типы контента
+
+В интерфейсе создания новой записи канала сейчас доступны только:
+
+- `POST (10)` — Пост;
+- `TEXT_ENTRYPOINT (100)` — Оглавление канала.
+
+Варианты `TEXT_EXERCISE (110)`, `TEXT_SERVICE (120)` и `TEXT_COURSE (130)` убраны только из формы создания новой записи. Их константы и обработчики чтения сохранены для совместимости со старыми данными.