Compare commits

...
19 Commits
Author SHA256 Message Date
AidarKC c13734cbc9 Добавить email-подтверждение бесплатной регистрации 2026-11-04 13:39:07 +03:00
AidarKC e78402c860 Документировать создание HEADER после регистрации 2026-10-29 13:24:13 +03:00
AidarKC 2ce80eeaef Добавить создание HEADER-блока после регистрации 2026-10-29 13:24:05 +03:00
AidarKC 551bdc2d65 Документировать Base64 ключ blockchain state 2026-10-29 13:12:30 +03:00
AidarKC f507bdb343 Нормализовать ключ free-блокчейна в Base64 2026-10-29 13:11:52 +03:00
AidarKC 395aa62bda Промежуточно: синхронизировать регистр логинов 2026-10-29 13:10:12 +03:00
AidarKC d2b2876a79 Обновить публичные ссылки и аватары каналов 2026-10-28 20:03:34 +03:00
AidarKC 8bb7d39c76 Недоделано: канонизировать login в заголовке блокчейна 2026-10-28 20:02:38 +03:00
AidarKC e296217f21 Учитывать регистр логина в состоянии блокчейна 2026-10-28 19:21:33 +03:00
AidarKC c0257f4be2 Восстанавливать blockchain state free-пользователей 2026-10-28 19:16:01 +03:00
AidarKC 7b88b61b22 Смена пароля работает: восстановить ротацию ключей 2026-10-28 19:00:46 +03:00
AidarKC ab61787ee7 Исправить чистый старт PostgreSQL и Solana sync 2026-10-28 12:51:43 +03:00
AidarKC 219a65ae27 Очистить временный PDA-очиститель и обновить T3 логин 2026-10-28 12:45:35 +03:00
AidarKC 94d4665185 Исправить регистрацию free-пользователей без учёта регистра
НЕ ПРОВЕРЕНО: учтены логины с большими и маленькими буквами.

Добавлен временный devnet-смарт-контракт для очистки тестового аккаунта от старых логинов; после сброса его необходимо удалить и восстановить штатный контракт.
2026-10-28 12:19:19 +03:00
AidarKC ce97171d5a Унифицировать платный статус регистрации 2026-10-28 11:28:59 +03:00
AidarKC a22f590395 апдейт по регистрации 2026-10-28 11:27:42 +03:00
AidarKC a520c5c5e1 Регистрация: бесплатная регистрация работает 2026-10-24 16:17:34 +03:00
AidarKC cab26bbf41 Регистрация V2: не проверено end-to-end 2026-10-23 19:21:52 +03:00
AidarKC 6c8159c5f7 Доработка логина и темы 2026-10-23 12:18:27 +03:00
163 changed files with 6494 additions and 1231 deletions
@@ -2,6 +2,7 @@ package server.archive;
import blockchain.Ans104DataItem;
import blockchain.BchBlockEntry;
import server.archive.registration.VerifiedFreeRegistrationImporter;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
@@ -9,6 +10,7 @@ import org.slf4j.LoggerFactory;
import server.logic.ws_protocol.JSON.handlers.blockchain.Net_AddBlock_Handler;
import server.sync.BlockchainResyncGuard;
import shine.db.DbController;
import utils.config.AppConfig;
import shine.db.dao.ArweaveBlockImportDAO;
import shine.db.dao.BlockchainStateDAO;
import shine.db.dao.BlocksDAO;
@@ -36,7 +38,7 @@ import java.time.Duration;
import java.util.*;
/**
* Discovers individual App=test5591 DataItems and imports the exact signed ANS-104 bytes.
* Discovers individual App=test5592 DataItems and imports the exact signed ANS-104 bytes.
* The importer is transport-agnostic: a DataItem may have reached Arweave through Turbo
* or inside a direct server-created ANS-104 bundle.
*/
@@ -50,6 +52,8 @@ public final class ArweaveBlockSyncService {
.connectTimeout(Duration.ofSeconds(20))
.followRedirects(HttpClient.Redirect.NORMAL)
.build();
private final VerifiedFreeRegistrationImporter registrationImporter = new VerifiedFreeRegistrationImporter(
AppConfig.getInstance().getBoolean("freeRegistration.email.allowReuse", false));
private final ArweaveBlockImportDAO importDAO = ArweaveBlockImportDAO.getInstance();
private final BlocksDAO blocksDAO = BlocksDAO.getInstance();
private final SolanaUserPdaCurrentDAO usersDAO = SolanaUserPdaCurrentDAO.getInstance();
@@ -68,6 +72,7 @@ public final class ArweaveBlockSyncService {
public void runCycle() throws Exception {
recoverInterruptedCanonicalRebuilds();
discover();
discoverFreeRegistrations();
drainQueue();
}
@@ -116,6 +121,12 @@ public final class ArweaveBlockSyncService {
try {
DownloadedDataItem downloaded = downloadSignedDataItem(dataItemId);
if (isRegistrationItem(downloaded.rawDataItem())) {
registrationImporter.importSigned(downloaded.rawDataItem(),
VerifiedFreeRegistrationImporter.Provenance.ARWEAVE_CONFIRMED);
unresolvedDownloads.remove(dataItemId);
continue; // Не парсить регистрацию как BchBlockEntry.
}
unresolvedDownloads.remove(dataItemId);
if (importDAO.enqueueIfMissing(id32, downloaded.rootTxId(), height, downloaded.rawDataItem(), System.currentTimeMillis())) discovered++;
} catch (RetryableDataItemDownloadException e) {
@@ -172,6 +183,18 @@ public final class ArweaveBlockSyncService {
continue;
}
if (isRegistrationItem(downloaded.rawDataItem())) {
try {
registrationImporter.importSigned(downloaded.rawDataItem(),
VerifiedFreeRegistrationImporter.Provenance.ARWEAVE_CONFIRMED);
unresolvedDownloads.remove(pending.dataItemId());
} catch (Exception e) {
unresolvedDownloads.remove(pending.dataItemId());
unresolvedDownloads.put(pending.dataItemId(), pending);
log.debug("Registration {} awaits namespace/DB sync or retry: {}", pending.dataItemId(), e.getMessage());
}
continue;
}
if (importDAO.enqueueIfMissing(pending.id32(), downloaded.rootTxId(), pending.height(),
downloaded.rawDataItem(), System.currentTimeMillis())) {
queued++;
@@ -474,10 +497,84 @@ public final class ArweaveBlockSyncService {
}finally{BlockchainResyncGuard.end(activeName);}
}
/** Независимый GraphQL курсор для t=reg: не смешивается с блоковой очередью. */
private void discoverFreeRegistrations() throws Exception {
long stored;
try (Connection c = DbController.getInstance().getConnection();
PreparedStatement ps = c.prepareStatement(
"SELECT last_block_height FROM free_registration_arweave_sync_state WHERE id=1");
ResultSet rs = ps.executeQuery()) {
stored = rs.next() ? rs.getLong(1) : 0;
}
long minHeight = Math.max(cfg.syncStartBlockHeight(), stored);
long high = minHeight;
long retryFrom = Long.MAX_VALUE;
String cursor = null;
int count = 0;
do {
JsonNode response = graphQlPage(minHeight, cursor, true);
if (response.has("errors")) throw new IOException("Registration GraphQL errors: " + response.path("errors"));
JsonNode txs = response.path("data").path("transactions");
JsonNode edges = txs.path("edges");
if (!edges.isArray()) throw new IOException("Registration GraphQL returned no edges");
String next = null;
for (JsonNode edge : edges) {
next = edge.path("cursor").asText(null);
JsonNode node = edge.path("node");
String id = node.path("id").asText("").trim();
long height = node.path("block").path("height").asLong(-1);
if (id.isBlank() || height < 0) continue; // мгновенный Turbo-импорт не зависит от height
high = Math.max(high, height);
try {
byte[] idBytes = B64URL.decode(id);
if (idBytes.length != 32) throw new IllegalArgumentException("Malformed id");
DownloadedDataItem item = downloadSignedDataItem(id);
if (!isRegistrationItem(item.rawDataItem()))
throw new IllegalArgumentException("GraphQL registration tag is not present in signed bytes");
registrationImporter.importSigned(item.rawDataItem(),
VerifiedFreeRegistrationImporter.Provenance.ARWEAVE_CONFIRMED);
count++;
} catch (RetryableDataItemDownloadException e) {
retryFrom = Math.min(retryFrom, height);
log.debug("Registration DataItem {} is not downloadable yet", id);
} catch (IllegalArgumentException e) {
log.warn("Rejecting invalid registration DataItem {}: {}", id, e.getMessage());
} catch (Exception e) {
retryFrom = Math.min(retryFrom, height);
log.warn("Registration DataItem {} import deferred: {}", id, e.getMessage());
}
}
cursor = txs.path("pageInfo").path("hasNextPage").asBoolean(false) ? next : null;
if (txs.path("pageInfo").path("hasNextPage").asBoolean(false) && (cursor == null || cursor.isBlank()))
throw new IOException("Registration GraphQL cursor missing");
} while (cursor != null);
long checkpoint = retryFrom == Long.MAX_VALUE ? high : Math.min(high, retryFrom);
try (Connection c = DbController.getInstance().getConnection();
PreparedStatement ps = c.prepareStatement("""
UPDATE free_registration_arweave_sync_state
SET last_block_height=?, updated_at_ms=? WHERE id=1
""")) {
ps.setLong(1, checkpoint); ps.setLong(2, System.currentTimeMillis()); ps.executeUpdate();
}
if (count > 0) log.info("Registration discovery verified {} DataItems; checkpoint={}", count, checkpoint);
}
private static boolean isRegistrationItem(byte[] raw) {
Ans104DataItem item = new Ans104DataItem(raw);
return item.tags().contains(new Ans104DataItem.Tag("t", "reg"));
}
private JsonNode graphQlPage(long minHeight, String cursor) throws Exception {
return graphQlPage(minHeight, cursor, false);
}
private JsonNode graphQlPage(long minHeight, String cursor, boolean registrationsOnly) throws Exception {
String after = cursor == null ? "null" : "\"" + escapeGraphQl(cursor) + "\"";
String query = "query { transactions(tags:[{name:\"" + ArweaveBlocksConfig.TEST_TAG_NAME + "\",values:[\""
+ ArweaveBlocksConfig.TEST_TAG_VALUE + "\"]}], block:{min:" + minHeight + "}, first:"
String tagFilter = "{name:\"" + ArweaveBlocksConfig.TEST_TAG_NAME + "\",values:[\""
+ ArweaveBlocksConfig.TEST_TAG_VALUE + "\"]}" +
(registrationsOnly ? ",{name:\"t\",values:[\"reg\"]}" : "");
String query = "query { transactions(tags:[" + tagFilter + "], block:{min:" + minHeight + "}, first:"
+ cfg.syncPageSize() + ", after:" + after
+ ", sort:HEIGHT_ASC) { pageInfo { hasNextPage } edges { cursor node { id block { height } } } } }";
String body = MAPPER.writeValueAsString(Map.of("query", query));
@@ -0,0 +1,129 @@
package server.archive.registration;
import server.archive.ArweaveBlocksConfig;
import server.archive.TurboDataItemUploader;
import server.logic.ws_protocol.JSON.handlers.registration.RegistrationApiBridge;
import server.logic.ws_protocol.JSON.handlers.registration.Net_Registration_Request;
import shine.db.DbController;
import utils.config.AppConfig;
import javax.sql.DataSource;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.Base64;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Logger;
/** Единственная точка подключения API без циклической зависимости Gradle-модулей. */
public final class FreeRegistrationApiBootstrap {
private static volatile FreeRegistrationWorkflow workflow;
private static volatile LocalRegistrarSigner signer;
private FreeRegistrationApiBootstrap() {}
public static synchronized void startOrThrow() throws Exception {
if (workflow != null) return;
AppConfig cfg=AppConfig.getInstance();
LocalRegistrarSigner newSigner=null;
FreeRegistrationIssuer issuer=null;
FreeRegistrationPublisher publisher=null;
RegistrationEmailSender emailSender=null;
if (cfg.getBoolean("freeRegistration.enabled",false)) {
boolean allowEmailReuse=cfg.getBoolean("freeRegistration.email.allowReuse",false);
// Не выводить seed/path в журнал ни при успешном старте, ни при ошибке.
ArweaveBlocksConfig transport=ArweaveBlocksConfig.load();
if(transport.publishMode()!=ArweaveBlocksConfig.PublishMode.TURBO)
throw new IllegalStateException("Free registration requires Turbo transport");
newSigner=LocalRegistrarSigner.fromConfig(cfg);
issuer=new FreeRegistrationIssuer(dbSource(),newSigner,allowEmailReuse);
publisher=new FreeRegistrationPublisher(issuer,new TurboDataItemUploader(transport),
new VerifiedFreeRegistrationImporter(allowEmailReuse));
// Секрет берём ТОЛЬКО из окружения, не из файлов репозитория.
String resendKey=System.getenv("RESEND_API_KEY");
if(resendKey==null || resendKey.isBlank())
resendKey=cfg.getStringOrEmpty("freeRegistration.email.apiKey");
emailSender=new ResendRegistrationEmailSender(resendKey,
cfg.getStringOrEmpty("freeRegistration.email.from").isBlank()
? "SHiNE <noreply@shineup.me>"
: cfg.getStringOrEmpty("freeRegistration.email.from"));
}
FreeRegistrationWorkflow newWorkflow=new FreeRegistrationWorkflow(issuer,publisher,emailSender,
cfg.getBoolean("freeRegistration.email.allowTestCode",false),
cfg.getBoolean("freeRegistration.email.allowReuse",false));
RegistrationApiBridge.install((op,req)->dispatch(newWorkflow,op,req));
signer=newSigner; workflow=newWorkflow;
}
public static synchronized void close() {
RegistrationApiBridge.uninstall();
workflow=null;
if(signer!=null) signer.close();
signer=null;
}
public static Map<String,Object> dispatch(FreeRegistrationWorkflow w, String op,Net_Registration_Request req) throws Exception {
Map<String,Object> out=new LinkedHashMap<>();
switch(op) {
case "GetNamespaces" -> {
out.put("namespaces",w.listNamespaces().stream().map(ns->Map.of(
"name",ns.namespace(), "type",ns.type(), "minLocalLength",ns.minLoginLength(),
"registrationFeeLamports",ns.priceLamports(), "defaultServerLogin",ns.serverLogin()==null?"":ns.serverLogin()
)).toList());
}
case "CheckRegistrationLogin" -> {
var info=w.checkLogin(req.getFullLogin());
out.put("loginAvailable",info.loginAvailable());
out.put("namespaceType",info.namespaceType());
out.put("minLocalLength",info.minLocalLength());
out.put("registrationFeeLamports",info.registrationFeeLamports());
}
case "CheckRegistrationEmail" -> out.put("emailAvailable",w.checkEmail(req.getEmail()).emailAvailable());
case "StartFreeRegistration" -> {
var state=w.start(req.getFullLogin(),decodeKey(req.getRootPublicKeyB64()),
decodeKey(req.getBlockchainPublicKeyB64()),decodeKey(req.getClientPublicKeyB64()),req.getEmail());
out.put("challengeId",state.challengeId()); out.put("expiresAtMs",state.expiresAtMs());
}
case "ConfirmFreeRegistration" -> {
var value=w.confirm(req.getChallengeId(),req.getCode());
out.put("fullLogin",value.fullLogin());out.put("dataItemId",value.dataItemId());
out.put("publicationStatus",value.state());out.put("chainConfirmed",false);
}
case "GetRegistrationStatus" -> {
var value=w.getStatus(req.getFullLogin());
out.put("registrationStatus",value.status());
out.put("dataItemId",value.dataItemId()==null?"":value.dataItemId());
out.put("publicationStatus",value.publicationStatus()==null?"":value.publicationStatus());
// Публичная историческая часть сертификата для бесплатного → Solana upgrade.
if("FREE_CERT".equals(value.status())) {
out.put("innerSignature64B64",value.innerSignature64B64()==null?"":value.innerSignature64B64());
out.put("rootPublicKey",value.rootPublicKey()==null?"":value.rootPublicKey());
out.put("blockchainPublicKey",value.blockchainPublicKey()==null?"":value.blockchainPublicKey());
out.put("clientPublicKey",value.clientPublicKey()==null?"":value.clientPublicKey());
out.put("defaultServerLogin",value.defaultServerLogin()==null?"":value.defaultServerLogin());
}
}
default -> throw new IllegalArgumentException("Unknown registration operation");
}
return out;
}
private static byte[] decodeKey(String base64) {
if(base64==null || base64.length()>64)throw new IllegalArgumentException("Invalid public key");
byte[] decoded=Base64.getDecoder().decode(base64);
if(decoded.length!=32)throw new IllegalArgumentException("Invalid public key length");
return decoded;
}
private static DataSource dbSource() {
return new DataSource() {
@Override public Connection getConnection() throws SQLException {return DbController.getInstance().getConnection();}
@Override public Connection getConnection(String u,String p) throws SQLException {throw new SQLFeatureNotSupportedException();}
@Override public PrintWriter getLogWriter(){return null;}
@Override public void setLogWriter(PrintWriter p){}
@Override public void setLoginTimeout(int t){}
@Override public int getLoginTimeout(){return 0;}
@Override public Logger getParentLogger(){return Logger.getGlobal();}
@Override public <T> T unwrap(Class<T> type) throws SQLException {throw new SQLFeatureNotSupportedException();}
@Override public boolean isWrapperFor(Class<?> type){return false;}
};
}
}
@@ -0,0 +1,115 @@
package server.archive.registration;
import blockchain.Ans104DataItem;
import blockchain.ShineProtocolTags;
import utils.crypto.Ed25519Util;
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.text.Normalizer;
import java.util.Arrays;
import java.util.Base64;
import java.util.List;
import java.util.Locale;
/** Строгое формирование и проверка двух подписей нового независимого DataItem `t=reg`. */
public final class FreeRegistrationCertificateV1 {
private static final byte[] DOMAIN = "SHiNE_FREE_REG_V1\0".getBytes(StandardCharsets.UTF_8);
private static final List<Ans104DataItem.Tag> TAGS = List.of(
new Ans104DataItem.Tag(ShineProtocolTags.APP_TAG_NAME, ShineProtocolTags.APP_TAG_VALUE),
new Ans104DataItem.Tag("t", "reg"),
new Ans104DataItem.Tag("Protocol", "SHiNE-Free-Registration-V1"));
public record Verified(String login, byte[] rootKey, byte[] blockchainKey,
byte[] clientKey, byte[] innerSignature,
byte[] emailSha256, byte[] owner32, String idBase64Url) {}
private FreeRegistrationCertificateV1() {}
public static String validateLogin(String login) {
if (login == null || !login.matches("[A-Za-z0-9_]+@[a-z0-9_]+") || login.length() > 30)
throw new IllegalArgumentException("Full login must use ASCII letters (any local-part case), lowercase namespace, <= 30 bytes");
return login;
}
public static byte[] identityFields(String login, byte[] root32, byte[] blockchain32, byte[] client32) {
byte[] name = validateLogin(login).getBytes(StandardCharsets.UTF_8);
require32(root32); require32(blockchain32); require32(client32);
ByteArrayOutputStream out = new ByteArrayOutputStream();
out.write(1); out.write(0); out.write(name.length); out.writeBytes(name);
out.writeBytes(root32); out.writeBytes(blockchain32); out.writeBytes(client32);
return out.toByteArray();
}
public static byte[] innerMessage(byte[] identity) {
ByteArrayOutputStream out = new ByteArrayOutputStream();
out.writeBytes(DOMAIN); out.writeBytes(identity);
return out.toByteArray();
}
public static String normalizeEmail(String email) {
if (email == null) throw new IllegalArgumentException("Email is required");
String value = Normalizer.normalize(email.strip(), Normalizer.Form.NFC).toLowerCase(Locale.ROOT);
if (value.isBlank() || value.indexOf('@') < 1 || value.contains(" "))
throw new IllegalArgumentException("Invalid email");
return value;
}
public static byte[] emailHash(String email) {
return sha256(normalizeEmail(email).getBytes(StandardCharsets.UTF_8));
}
public static byte[] issue(String login, byte[] root32, byte[] blockchain32,
byte[] client32, String email, RegistrarSigner signer) {
byte[] fields = identityFields(login, root32, blockchain32, client32);
byte[] inner = signer.sign(innerMessage(fields));
if (inner.length != 64) throw new IllegalStateException("Invalid inner signature length");
ByteArrayOutputStream payload = new ByteArrayOutputStream();
payload.writeBytes(fields);
payload.writeBytes(inner);
payload.writeBytes(emailHash(email));
byte[] data = payload.toByteArray();
byte[] owner = signer.publicKey32();
require32(owner);
byte[] outer = signer.sign(Ans104DataItem.buildSigningMessage(owner, TAGS, data));
byte[] raw = Ans104DataItem.serializeEd25519(outer, owner, TAGS, data);
verify(raw, owner);
return raw;
}
public static Verified verify(byte[] signedDataItem, byte[] registrarPublicKey32) {
require32(registrarPublicKey32);
Ans104DataItem item = new Ans104DataItem(signedDataItem);
if (!item.ownerEquals(registrarPublicKey32) || !item.verifySignature())
throw new IllegalArgumentException("Invalid outer ANS-104 registrar signature");
if (!item.tags().equals(TAGS) || item.target().length != 0 || item.anchor().length != 0)
throw new IllegalArgumentException("Unexpected registration tags/target/anchor");
byte[] data = item.data();
if (data.length < 3 + 96 + 64 + 32 || data[0] != 1 || data[1] != 0)
throw new IllegalArgumentException("Invalid certificate version/length");
int len = data[2] & 0xff;
if (data.length != 3 + len + 96 + 64 + 32)
throw new IllegalArgumentException("Invalid certificate byte length");
String login = validateLogin(new String(data, 3, len, StandardCharsets.UTF_8));
int offset = 3 + len;
byte[] root = Arrays.copyOfRange(data, offset, offset+32); offset += 32;
byte[] blockchain = Arrays.copyOfRange(data, offset, offset+32); offset += 32;
byte[] client = Arrays.copyOfRange(data, offset, offset+32); offset += 32;
byte[] innerSig = Arrays.copyOfRange(data, offset, offset+64); offset += 64;
byte[] emailSha = Arrays.copyOfRange(data, offset, offset+32);
byte[] fields = Arrays.copyOfRange(data, 0, 3 + len + 96);
if (!Ed25519Util.verify(innerMessage(fields), innerSig, registrarPublicKey32))
throw new IllegalArgumentException("Invalid inner certificate signature");
return new Verified(login, root, blockchain, client, innerSig, emailSha,
item.owner32(), Base64.getUrlEncoder().withoutPadding().encodeToString(item.id32()));
}
private static void require32(byte[] key) {
if (key == null || key.length != 32) throw new IllegalArgumentException("Expected 32-byte public key");
}
private static byte[] sha256(byte[] data) {
try { return MessageDigest.getInstance("SHA-256").digest(data); }
catch (Exception e) { throw new IllegalStateException("SHA-256 unavailable", e); }
}
}
@@ -0,0 +1,74 @@
package server.archive.registration;
import sync.util.Base58Util;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Arrays;
/** Выдача (без публикации). Stage 8 публикует через Turbo и импортирует тот же raw DataItem. */
public final class FreeRegistrationIssuer {
private final DataSource db;
private final RegistrarSigner signer;
private final boolean allowEmailReuse;
public FreeRegistrationIssuer(DataSource db, RegistrarSigner signer) {
this(db, signer, false);
}
public FreeRegistrationIssuer(DataSource db, RegistrarSigner signer, boolean allowEmailReuse) {
this.db = java.util.Objects.requireNonNull(db);
this.signer = java.util.Objects.requireNonNull(signer);
this.allowEmailReuse = allowEmailReuse;
}
/** Выдаётся только после успешной проверки challenge в FreeRegistrationWorkflow. */
synchronized byte[] issue(String fullLogin, byte[] root32, byte[] blockchain32,
byte[] client32, String email) throws Exception {
FreeRegistrationCertificateV1.validateLogin(fullLogin);
String namespace = fullLogin.substring(fullLogin.indexOf('@') + 1);
byte[] expectedEmail = FreeRegistrationCertificateV1.emailHash(email);
try (Connection conn = db.getConnection()) {
conn.setReadOnly(true);
String sql = """
SELECT namespace_type, min_localpart_len, registrar_pubkey, default_server_login
FROM shine_namespace_current WHERE namespace = ?
""";
try (PreparedStatement statement = conn.prepareStatement(sql)) {
statement.setString(1, namespace);
try (ResultSet rs = statement.executeQuery()) {
if (!rs.next() || rs.getInt("namespace_type") != 2 ||
fullLogin.indexOf('@') < rs.getInt("min_localpart_len"))
throw new IllegalArgumentException("Free namespace is unavailable");
byte[] nsPub = Base58Util.decode(rs.getString("registrar_pubkey"));
if (!Arrays.equals(nsPub, signer.publicKey32()))
throw new IllegalStateException("Registrar public key does not match on-chain namespace");
String server = rs.getString("default_server_login");
if (server == null || server.isBlank())
throw new IllegalStateException("Free namespace server is not configured");
}
}
try (PreparedStatement ps = conn.prepareStatement(
"SELECT 1 FROM user_identity_current WHERE normalized_login = ?")) {
ps.setString(1, fullLogin.toLowerCase(java.util.Locale.ROOT));
try (ResultSet rs = ps.executeQuery()) {
if (rs.next()) throw new IllegalArgumentException("Login is already registered");
}
}
if (!allowEmailReuse) {
try (PreparedStatement ps = conn.prepareStatement(
"SELECT 1 FROM free_registration_certificate WHERE email_sha256 = ?")) {
ps.setBytes(1, expectedEmail);
try (ResultSet rs = ps.executeQuery()) {
if (rs.next()) throw new IllegalArgumentException("Email hash already registered");
}
}
}
}
// Это только подписанный артефакт, не активная регистрация. Перед Turbo
// и локальным импортом обязательно повторять уникальность в транзакции БД.
return FreeRegistrationCertificateV1.issue(fullLogin, root32, blockchain32, client32, email, signer);
}
}
@@ -0,0 +1,30 @@
package server.archive.registration;
import server.archive.TurboDataItemUploader;
import blockchain.Ans104DataItem;
/** Отдельный транспорт регистрации. Публикация не является пользовательским AddBlock. */
public final class FreeRegistrationPublisher {
private final FreeRegistrationIssuer issuer;
private final TurboDataItemUploader uploader;
private final VerifiedFreeRegistrationImporter importer;
public FreeRegistrationPublisher(FreeRegistrationIssuer issuer, TurboDataItemUploader uploader,
VerifiedFreeRegistrationImporter importer) {
this.issuer = java.util.Objects.requireNonNull(issuer);
this.uploader = java.util.Objects.requireNonNull(uploader);
this.importer = java.util.Objects.requireNonNull(importer);
}
/** Для повтора ПОСЛЕ потери ACK передавайте точно те же signedBytes. */
public VerifiedFreeRegistrationImporter.ImportResult publishSigned(byte[] signedBytes) throws Exception {
Ans104DataItem parsed = new Ans104DataItem(signedBytes);
importer.validateForUpload(signedBytes); // строго до HTTP/Turbo списания кредитов
// Импорт на этой точке вызовет полную проверку обеих подписей и namespace
// ПОСЛЕ успешного ACK Turbo, а не до окончательного подтверждения Arweave.
TurboDataItemUploader.UploadResult acknowledged = uploader.upload(signedBytes, parsed.id32());
String expectedId = java.util.Base64.getUrlEncoder().withoutPadding().encodeToString(parsed.id32());
if (!expectedId.equals(acknowledged.dataItemId()))
throw new IllegalStateException("Unexpected Turbo DataItem id");
return importer.importSigned(signedBytes, VerifiedFreeRegistrationImporter.Provenance.TURBO_ACCEPTED);
}
}
@@ -0,0 +1,228 @@
package server.archive.registration;
import shine.db.DbController;
import java.security.SecureRandom;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.time.Duration;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Base64;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/** Внутренний state machine публичных операций регистрации v2. */
public final class FreeRegistrationWorkflow {
public record NamespaceInfo(String namespace, int type, int minLoginLength, String priceLamports, String serverLogin) {}
public record Availability(boolean nameFree, boolean emailHashFree) {}
public record LoginCheck(boolean loginAvailable, int namespaceType, int minLocalLength, String registrationFeeLamports) {}
public record EmailCheck(boolean emailAvailable) {}
public record Started(String challengeId, long expiresAtMs) {}
public record Completed(String fullLogin, String dataItemId, String state, boolean alreadyImported) {}
public record State(String status, String dataItemId, String publicationStatus, String innerSignature64B64,
String rootPublicKey, String blockchainPublicKey, String clientPublicKey,
String defaultServerLogin) {}
private record Draft(String login, byte[] root, byte[] blockchain, byte[] client, String email,
long expiresAtMs, byte[] codeHash, int attempts, boolean delivered,
boolean verified, byte[] signedBytes) {
Draft update(int attempts, boolean delivered, boolean verified, byte[] signedBytes) {
return new Draft(login, root, blockchain, client, email, expiresAtMs,
codeHash, attempts, delivered, verified, signedBytes);
}
}
private final Map<String, Draft> pending = new ConcurrentHashMap<>();
// Не храним в БД почтовые адреса, пока регистрация не завершилась.
private final Map<String, Long> recentEmails = new HashMap<>();
private final Map<String, Long> recentLogins = new HashMap<>();
private final java.util.ArrayDeque<Long> globalSendTimes = new java.util.ArrayDeque<>();
private static final long TTL_MS = Duration.ofHours(1).toMillis();
private static final long EMAIL_COOLDOWN_MS = Duration.ofMinutes(1).toMillis();
private static final long GLOBAL_WINDOW_MS = Duration.ofHours(1).toMillis();
private static final int MAX_EMAILS_PER_HOUR = 60;
private static final int MAX_ATTEMPTS = 5;
private static final int MAX_PENDING = 512;
private static final SecureRandom RANDOM = new SecureRandom();
private final FreeRegistrationIssuer issuer;
private final FreeRegistrationPublisher publisher;
private final RegistrationEmailSender emailSender;
private final boolean allowTestCode;
private final boolean allowEmailReuse;
public FreeRegistrationWorkflow(FreeRegistrationIssuer issuer, FreeRegistrationPublisher publisher,
RegistrationEmailSender emailSender, boolean allowTestCode, boolean allowEmailReuse) {
if ((issuer == null) != (publisher == null)) throw new IllegalArgumentException("Signer/publisher mismatch");
if (issuer != null && emailSender == null) throw new IllegalArgumentException("Email sender is required");
this.issuer = issuer;
this.publisher = publisher;
this.emailSender = emailSender;
this.allowTestCode = allowTestCode;
this.allowEmailReuse = allowEmailReuse;
}
public FreeRegistrationWorkflow(FreeRegistrationIssuer issuer, FreeRegistrationPublisher publisher,
RegistrationEmailSender emailSender, boolean allowTestCode) {
this(issuer, publisher, emailSender, allowTestCode, false);
}
public FreeRegistrationWorkflow(FreeRegistrationIssuer issuer, FreeRegistrationPublisher publisher,
RegistrationEmailSender emailSender) {
this(issuer, publisher, emailSender, false);
}
public FreeRegistrationWorkflow(FreeRegistrationIssuer issuer, FreeRegistrationPublisher publisher) {
this(issuer, publisher, null);
}
public List<NamespaceInfo> listNamespaces() throws Exception {
List<NamespaceInfo> result = new ArrayList<>();
try (Connection c = DbController.getInstance().getConnection();
PreparedStatement ps = c.prepareStatement("""
SELECT namespace,namespace_type,min_localpart_len,registration_fee_lamports,default_server_login
FROM shine_namespace_current ORDER BY namespace
"""); ResultSet rs = ps.executeQuery()) {
while (rs.next()) result.add(new NamespaceInfo(rs.getString(1),rs.getInt(2),rs.getInt(3),
rs.getString(4),rs.getString(5)));
}
return List.copyOf(result);
}
public LoginCheck checkLogin(String login) throws Exception {
FreeRegistrationCertificateV1.validateLogin(login);
String namespace=login.substring(login.indexOf('@')+1);
try (Connection c=DbController.getInstance().getConnection()) {
int type, minimum; String fee;
try (PreparedStatement p=c.prepareStatement("SELECT namespace_type,min_localpart_len,registration_fee_lamports FROM shine_namespace_current WHERE namespace=?")) {
p.setString(1,namespace);
try (ResultSet rs=p.executeQuery()) {
if (!rs.next()) throw new IllegalArgumentException("Namespace is unavailable");
type=rs.getInt(1); minimum=rs.getInt(2); fee=rs.getString(3);
if (login.indexOf('@') < minimum) throw new IllegalArgumentException("Login shorter than namespace minimum");
}
}
try (PreparedStatement p=c.prepareStatement("SELECT 1 FROM user_identity_current WHERE normalized_login=?")) {
p.setString(1, login.toLowerCase(java.util.Locale.ROOT));
try (ResultSet rs=p.executeQuery()) { return new LoginCheck(!rs.next(),type,minimum,fee); }
}
}
}
public EmailCheck checkEmail(String email) throws Exception {
byte[] hash=FreeRegistrationCertificateV1.emailHash(email);
if (allowEmailReuse) return new EmailCheck(true);
try (Connection c=DbController.getInstance().getConnection();
PreparedStatement p=c.prepareStatement("SELECT 1 FROM free_registration_certificate WHERE email_sha256=?")) {
p.setBytes(1,hash);
try(ResultSet rs=p.executeQuery()) { return new EmailCheck(!rs.next()); }
}
}
/** Устаревший внутренний helper: внешний API использует две отдельные операции. */
public Availability availability(String login,String email) throws Exception {
return new Availability(checkLogin(login).loginAvailable(),checkEmail(email).emailAvailable());
}
public Started start(String login, byte[] root, byte[] blockchain, byte[] client, String email) throws Exception {
if (issuer == null || publisher == null || emailSender == null)
throw new IllegalStateException("Free registration is disabled");
FreeRegistrationCertificateV1.identityFields(login,root,blockchain,client);
LoginCheck checked = checkLogin(login);
if (checked.namespaceType()!=2 || !checked.loginAvailable())
throw new IllegalStateException("Login is unavailable");
if (!checkEmail(email).emailAvailable()) throw new IllegalStateException("Email is unavailable");
String cleanEmail=FreeRegistrationCertificateV1.normalizeEmail(email);
String normalizedLogin=login.toLowerCase(java.util.Locale.ROOT);
byte[] id=new byte[32]; RANDOM.nextBytes(id);
String challenge=Base64.getUrlEncoder().withoutPadding().encodeToString(id);
String code=RegistrationEmailCode.generate();
long now=System.currentTimeMillis();
long expires=now+TTL_MS;
Draft draft=new Draft(login,root.clone(),blockchain.clone(),client.clone(),cleanEmail,
expires,RegistrationEmailCode.hash(challenge,code),0,false,false,null);
synchronized (this) {
pending.entrySet().removeIf(e->e.getValue().expiresAtMs < now);
recentEmails.entrySet().removeIf(e->e.getValue() < now-TTL_MS);
recentLogins.entrySet().removeIf(e->e.getValue() < now-TTL_MS);
while(!globalSendTimes.isEmpty() && globalSendTimes.peekFirst() < now-GLOBAL_WINDOW_MS)
globalSendTimes.removeFirst();
if (pending.size() >= MAX_PENDING) throw new IllegalStateException("Too many pending registrations");
if (now-recentEmails.getOrDefault(cleanEmail,0L) < EMAIL_COOLDOWN_MS ||
now-recentLogins.getOrDefault(normalizedLogin,0L) < EMAIL_COOLDOWN_MS)
throw new IllegalStateException("Please wait before requesting another code");
if (globalSendTimes.size() >= MAX_EMAILS_PER_HOUR)
throw new IllegalStateException("Email verification temporarily limited");
recentEmails.put(cleanEmail,now);
recentLogins.put(normalizedLogin,now);
globalSendTimes.addLast(now);
pending.put(challenge,draft);
}
try {
// Не блокируем monitor workflow на время HTTP-запроса к Resend.
emailSender.sendVerificationCode(cleanEmail,code);
} catch (Exception e) {
synchronized (this) {
pending.remove(challenge);
recentEmails.remove(cleanEmail,now);
recentLogins.remove(normalizedLogin,now);
globalSendTimes.removeFirstOccurrence(now);
}
throw e;
}
synchronized (this) {
// Новый успешно отправленный код заменяет старые заявки на тот же login/email.
pending.entrySet().removeIf(e -> !e.getKey().equals(challenge) &&
(e.getValue().email.equals(cleanEmail) ||
e.getValue().login.equalsIgnoreCase(login)));
pending.computeIfPresent(challenge,(key,d)->d.update(d.attempts,true,d.verified,d.signedBytes));
}
return new Started(challenge,expires);
}
boolean isValidVerificationCode(byte[] expectedHash, String challenge, String code) {
return (allowTestCode && "777777".equals(code))
|| RegistrationEmailCode.matches(expectedHash, challenge, code);
}
public synchronized Completed confirm(String challenge, String code) throws Exception {
if (publisher == null) throw new IllegalStateException("Free registration disabled");
if (challenge == null || challenge.isBlank())
throw new IllegalArgumentException("Registration challenge missing");
Draft d=pending.get(challenge);
if (d==null || d.expiresAtMs < System.currentTimeMillis()) {
pending.remove(challenge); throw new IllegalArgumentException("Registration challenge missing or expired");
}
if (!d.delivered) throw new IllegalStateException("Verification email is not delivered yet");
if (!d.verified) {
if (!isValidVerificationCode(d.codeHash, challenge, code)) {
if (d.attempts+1 >= MAX_ATTEMPTS) pending.remove(challenge);
else pending.put(challenge,d.update(d.attempts+1,true,false,d.signedBytes));
throw new IllegalArgumentException("Invalid email code");
}
// Если Turbo не ответит, подтверждённая заявка может быть повторена до TTL.
d=d.update(d.attempts,true,true,d.signedBytes);
pending.put(challenge,d);
}
byte[] signed=d.signedBytes;
if(signed==null) {
signed=issuer.issue(d.login,d.root,d.blockchain,d.client,d.email);
d=d.update(d.attempts,true,true,signed);
pending.put(challenge,d);
}
VerifiedFreeRegistrationImporter.ImportResult result=publisher.publishSigned(signed);
// Повтор использует тот же подписанный DataItem, без смены ключей и адреса email.
return new Completed(result.login(),result.dataItemId(),"TURBO_ACCEPTED",result.alreadyImported());
}
public State getStatus(String login) throws Exception {
FreeRegistrationCertificateV1.validateLogin(login);
try (Connection c=DbController.getInstance().getConnection();
PreparedStatement p=c.prepareStatement("""
SELECT i.registration_status,i.free_data_item_id,f.publication_status,f.inner_signature,
i.root_key,i.blockchain_key,i.client_key,n.default_server_login
FROM user_identity_current i
LEFT JOIN free_registration_certificate f ON f.data_item_id=i.free_data_item_id
LEFT JOIN shine_namespace_current n ON n.namespace=i.namespace
WHERE i.normalized_login=?
""")) {
p.setString(1,login.toLowerCase(java.util.Locale.ROOT));
try (ResultSet r=p.executeQuery()) {
return r.next()?new State(r.getString(1),r.getString(2),r.getString(3),
r.getBytes(4)==null?null:Base64.getEncoder().encodeToString(r.getBytes(4)),
r.getString(5),r.getString(6),r.getString(7),r.getString(8))
:new State("NOT_FOUND",null,null,null,null,null,null,null);
}
}
}
}
@@ -0,0 +1,43 @@
package server.archive.registration;
import utils.crypto.Ed25519Util;
import utils.config.AppConfig;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.Base64;
/** Временный signer. Файл вне Git: одно значение Base64 от 32-байтного Ed25519 seed. */
public final class LocalRegistrarSigner implements RegistrarSigner {
private final byte[] seed32;
private final byte[] publicKey32;
private boolean closed;
public LocalRegistrarSigner(byte[] seed) {
if (seed == null || seed.length != 32) throw new IllegalArgumentException("Registrar seed must be 32 bytes");
this.seed32 = seed.clone();
this.publicKey32 = Ed25519Util.derivePublicKey(seed32);
}
public static LocalRegistrarSigner fromConfig(AppConfig config) throws Exception {
if (!config.getBoolean("freeRegistration.enabled", false))
throw new IllegalStateException("Free registration is disabled");
String path = config.getStringOrEmpty("freeRegistration.registrarSeedFile");
if (path.isEmpty()) throw new IllegalStateException("Registrar key path is not configured");
byte[] seed = Base64.getDecoder().decode(Files.readString(Path.of(path), StandardCharsets.UTF_8).trim());
try { return new LocalRegistrarSigner(seed); }
finally { Arrays.fill(seed, (byte) 0); }
}
@Override public synchronized byte[] publicKey32() { return publicKey32.clone(); }
@Override public synchronized byte[] sign(byte[] message) {
if (closed) throw new IllegalStateException("Signer closed");
return Ed25519Util.sign(message, seed32);
}
@Override public synchronized void close() {
Arrays.fill(seed32, (byte) 0);
closed = true;
}
}
@@ -0,0 +1,8 @@
package server.archive.registration;
/** Интерфейс приватного регистратора: private key не передаётся в бизнес-логику. */
public interface RegistrarSigner extends AutoCloseable {
byte[] publicKey32();
byte[] sign(byte[] message);
@Override default void close() {}
}
@@ -0,0 +1,31 @@
package server.archive.registration;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.HexFormat;
/** Одноразовый код не сохраняется в открытом виде и не попадает в журнал. */
final class RegistrationEmailCode {
private static final SecureRandom RANDOM = new SecureRandom();
private RegistrationEmailCode() {}
static String generate() {
return String.format(java.util.Locale.ROOT, "%06d", RANDOM.nextInt(1_000_000));
}
static byte[] hash(String challengeId, String code) {
try {
MessageDigest md = MessageDigest.getInstance("SHA-256");
return md.digest((challengeId + ":" + code).getBytes(StandardCharsets.UTF_8));
} catch (NoSuchAlgorithmException e) {
throw new IllegalStateException("SHA-256 unavailable", e);
}
}
static boolean matches(byte[] expectedHash, String challengeId, String submitted) {
return submitted != null && submitted.matches("[0-9]{6}") &&
MessageDigest.isEqual(expectedHash, hash(challengeId, submitted));
}
}
@@ -0,0 +1,7 @@
package server.archive.registration;
/** Отправка кода. Детали внешнего почтового провайдера не влияют на протокол регистрации. */
@FunctionalInterface
public interface RegistrationEmailSender {
void sendVerificationCode(String recipient, String code) throws Exception;
}
@@ -0,0 +1,63 @@
package server.archive.registration;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.Map;
/** Транзакционная отправка через Resend: HTTP API, без SMTP и внешней Java SDK. */
public final class ResendRegistrationEmailSender implements RegistrationEmailSender {
private static final URI ENDPOINT = URI.create("https://api.resend.com/emails");
private static final String SUBJECT = "SHiNE — код подтверждения email";
private final HttpClient client = HttpClient.newBuilder()
.connectTimeout(Duration.ofSeconds(5)).build();
private final ObjectMapper mapper = new ObjectMapper();
private final String apiKey;
private final String from;
public ResendRegistrationEmailSender(String apiKey, String from) {
if (apiKey == null || apiKey.isBlank())
throw new IllegalStateException("Resend API key is required for free registration");
if (from == null || from.isBlank())
throw new IllegalStateException("Sender email is missing");
this.apiKey = apiKey.trim();
this.from = from.trim();
}
@Override
public void sendVerificationCode(String recipient, String code) throws Exception {
if (recipient == null || recipient.isBlank() || !code.matches("[0-9]{6}"))
throw new IllegalArgumentException("Invalid email verification request");
String text = "Добро пожаловать в SHiNE!\n\n"
+ "Для завершения регистрации введите код подтверждения:\n\n"
+ code + "\n\n"
+ "Код действителен в течение 1 часа.\n\n"
+ "Если вы не регистрировались в SHiNE, просто проигнорируйте это письмо.\n\n"
+ "Команда SHiNE";
String html = "<div style=\"font-family:Arial,sans-serif;max-width:520px;margin:auto;"
+ "padding:24px;color:#1d2433;line-height:1.6\">"
+ "<h2 style=\"margin:0 0 20px\">Добро пожаловать в SHiNE!</h2>"
+ "<p>Для завершения регистрации введите код подтверждения:</p>"
+ "<p style=\"font-size:32px;font-weight:700;letter-spacing:6px\">" + code + "</p>"
+ "<p>Код действителен в течение 1 часа.</p>"
+ "<p style=\"color:#5d6470\">Если вы не регистрировались в SHiNE, "
+ "просто проигнорируйте это письмо.</p><p>Команда SHiNE</p></div>";
String json = mapper.writeValueAsString(Map.of(
"from", from, "to", new String[]{recipient}, "subject", SUBJECT,
"text", text, "html", html));
HttpRequest request = HttpRequest.newBuilder(ENDPOINT)
.header("Authorization", "Bearer " + apiKey)
.header("Content-Type", "application/json")
.timeout(Duration.ofSeconds(12))
.POST(HttpRequest.BodyPublishers.ofString(json))
.build();
// Тело ошибки не выводим: нельзя логировать email или токен провайдера.
HttpResponse<Void> response = client.send(request, HttpResponse.BodyHandlers.discarding());
if (response.statusCode() < 200 || response.statusCode() >= 300)
throw new IllegalStateException("Resend delivery rejected (HTTP " + response.statusCode() + ")");
}
}
@@ -0,0 +1,184 @@
package server.archive.registration;
import shine.db.DbController;
import sync.util.Base58Util;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.Base64;
/** Только верифицированный сертификат. Локальная БД — проекция Arweave/Solana. */
public final class VerifiedFreeRegistrationImporter {
public enum Provenance { TURBO_ACCEPTED, ARWEAVE_CONFIRMED }
public record ImportResult(String login, String dataItemId, boolean alreadyImported, Provenance provenance) {}
private final boolean allowEmailReuse;
public VerifiedFreeRegistrationImporter() {
this(false);
}
public VerifiedFreeRegistrationImporter(boolean allowEmailReuse) {
this.allowEmailReuse = allowEmailReuse;
}
/** Предварительная проверка ДО Turbo: не расходовать кредиты на чужую/битую запись. */
public FreeRegistrationCertificateV1.Verified validateForUpload(byte[] raw) throws Exception {
if (raw == null || raw.length < 200 || raw.length > 16_384)
throw new IllegalArgumentException("Invalid registration size");
blockchain.Ans104DataItem item = new blockchain.Ans104DataItem(raw);
String login = extractCanonicalLogin(item);
try (Connection c = DbController.getInstance().getConnection()) {
String namespace = login.substring(login.indexOf('@') + 1);
var cert = FreeRegistrationCertificateV1.verify(raw, readRegistrar(c, namespace, login));
try (PreparedStatement ps = c.prepareStatement(
"SELECT free_data_item_id FROM user_identity_current WHERE normalized_login=?")) {
ps.setString(1, login.toLowerCase(java.util.Locale.ROOT));
try (ResultSet rs = ps.executeQuery()) {
if (rs.next() && !cert.idBase64Url().equals(rs.getString(1)))
throw new IllegalArgumentException("Login is already registered");
}
}
if (!allowEmailReuse) {
try (PreparedStatement ps = c.prepareStatement(
"SELECT data_item_id FROM free_registration_certificate WHERE email_sha256=?")) {
ps.setBytes(1, cert.emailSha256());
try (ResultSet rs = ps.executeQuery()) {
if (rs.next() && !cert.idBase64Url().equals(rs.getString(1)))
throw new IllegalArgumentException("Email hash belongs to another account");
}
}
}
return cert;
}
}
/** Единая точка импорта: один и тот же raw ANS-104 из Turbo и Arweave. */
public ImportResult importSigned(byte[] raw, Provenance provenance) throws Exception {
if (raw == null || raw.length > 16_384 || raw.length < 200)
throw new IllegalArgumentException("Invalid registration data item size");
// Сначала разбираем/проверяем структурный контейнер, затем сверяем owner с on-chain namespace.
blockchain.Ans104DataItem item = new blockchain.Ans104DataItem(raw);
String login = extractCanonicalLogin(item);
String namespace = login.substring(login.indexOf('@') + 1);
try (Connection c = DbController.getInstance().getConnection()) {
boolean oldAutoCommit = c.getAutoCommit();
c.setAutoCommit(false);
try {
byte[] registrar = readRegistrar(c, namespace, login);
FreeRegistrationCertificateV1.Verified cert = FreeRegistrationCertificateV1.verify(raw, registrar);
String id = cert.idBase64Url();
String publication = provenance == Provenance.ARWEAVE_CONFIRMED ? "ARWEAVE_CONFIRMED" : "TURBO_ACCEPTED";
long now = System.currentTimeMillis();
// Защита от коллизий и двойного импорта: имя и email захвачены индексами UNIQUE.
try (PreparedStatement check = c.prepareStatement("""
SELECT f.raw_signed_data_item, f.publication_status, u.root_key, u.client_key,
u.blockchain_key FROM free_registration_certificate f
JOIN user_identity_current u ON u.login=f.login
WHERE f.data_item_id=? FOR UPDATE OF f
""")) {
check.setString(1, id);
try (ResultSet r = check.executeQuery()) {
if (r.next()) {
if (!Arrays.equals(raw, r.getBytes(1)))
throw new SQLException("DataItem id collision with different raw bytes");
if (!r.getString(3).equals(Base58Util.encode(cert.rootKey())) ||
!r.getString(4).equals(Base58Util.encode(cert.clientKey())) ||
!r.getString(5).equals(Base58Util.encode(cert.blockchainKey())))
throw new SQLException("Accepted identity keys conflict with certificate");
if (provenance == Provenance.ARWEAVE_CONFIRMED) {
try (PreparedStatement up = c.prepareStatement("""
UPDATE free_registration_certificate SET publication_status='ARWEAVE_CONFIRMED',last_seen_at_ms=?
WHERE data_item_id=?
""")) {
up.setLong(1, now); up.setString(2, id); up.executeUpdate();
}
}
c.commit();
return new ImportResult(login, id, true, provenance);
}
}
}
try (PreparedStatement insert = c.prepareStatement("""
INSERT INTO user_identity_current (
login, normalized_login, namespace, registration_source, registration_status,
solana_pda_address, free_data_item_id, root_key, client_key, blockchain_key,
blockchain_name, is_server, registered_at_ms, updated_at_ms)
VALUES (?, ?, ?, 'ARWEAVE', 'FREE_CERT', NULL, ?, ?, ?, ?, ?, false, ?, ?)
""")) {
insert.setString(1, login); insert.setString(2, login.toLowerCase(java.util.Locale.ROOT)); insert.setString(3, namespace);
insert.setString(4, id); insert.setString(5, Base58Util.encode(cert.rootKey()));
insert.setString(6, Base58Util.encode(cert.clientKey()));
insert.setString(7, Base58Util.encode(cert.blockchainKey()));
insert.setString(8, login.toLowerCase(java.util.Locale.ROOT) + "-001"); insert.setLong(9, now); insert.setLong(10, now);
insert.executeUpdate();
}
// blockchain_state — обязательная runtime-проекция новой цепочки.
// Без неё первый пользовательский AddBlock (например, «О себе») будет
// отклонён ещё до проверки подписи.
try (PreparedStatement insert = c.prepareStatement("""
INSERT INTO blockchain_state_store (
login, fork_number, blockchain_key, size_limit, file_size_bytes,
last_block_number, last_block_hash, updated_at_ms)
VALUES (?, 1, ?, 100000, 0, -1, ?, ?)
""")) {
insert.setString(1, login);
// blockchain_state — runtime-слой: его ключ всегда Base64(32),
// как и у пользователей, импортированных из Solana PDA.
insert.setString(2, Base64.getEncoder().encodeToString(cert.blockchainKey()));
insert.setBytes(3, new byte[32]);
insert.setLong(4, now);
insert.executeUpdate();
}
try (PreparedStatement insert = c.prepareStatement("""
INSERT INTO free_registration_certificate (
data_item_id, login, namespace, email_sha256, inner_signature,
raw_signed_data_item, publication_status, registered_at_ms, last_seen_at_ms)
VALUES (?,?,?,?,?,?,?,?,?)
""")) {
insert.setString(1, id); insert.setString(2, login); insert.setString(3, namespace);
insert.setBytes(4, cert.emailSha256()); insert.setBytes(5, cert.innerSignature());
insert.setBytes(6, raw); insert.setString(7, publication);
insert.setLong(8, now); insert.setLong(9, now); insert.executeUpdate();
}
c.commit();
return new ImportResult(login, id, false, provenance);
} catch (Exception e) {
c.rollback(); throw e;
} finally { c.setAutoCommit(oldAutoCommit); }
}
}
private static String extractCanonicalLogin(blockchain.Ans104DataItem item) {
boolean marker = item.tags().contains(new blockchain.Ans104DataItem.Tag("t", "reg"));
if (!marker) throw new IllegalArgumentException("Not a registration DataItem");
byte[] bytes = item.data();
if (bytes.length < 3 || bytes[0] != 1 || bytes[1] != 0) throw new IllegalArgumentException("Bad certificate header");
int len = bytes[2] & 0xff;
if (len < 3 || len > 30 || bytes.length < 3 + len + 96 + 64 + 32)
throw new IllegalArgumentException("Invalid certificate login length");
return FreeRegistrationCertificateV1.validateLogin(
new String(bytes, 3, len, java.nio.charset.StandardCharsets.UTF_8));
}
private static byte[] readRegistrar(Connection c, String namespace, String login) throws Exception {
try (PreparedStatement ps = c.prepareStatement("""
SELECT registrar_pubkey, min_localpart_len, default_server_login
FROM shine_namespace_current WHERE namespace=? AND namespace_type=2
""")) {
ps.setString(1, namespace);
try (ResultSet rs = ps.executeQuery()) {
if (!rs.next()) throw new IllegalStateException("Unknown/free namespace not yet synchronized");
if (login.indexOf('@') < rs.getInt("min_localpart_len"))
throw new IllegalArgumentException("Login shorter than namespace minimum");
if (rs.getString("default_server_login") == null || rs.getString("default_server_login").isBlank())
throw new IllegalArgumentException("Namespace has no access server");
byte[] key = Base58Util.decode(rs.getString("registrar_pubkey"));
if (key.length != 32) throw new IllegalArgumentException("Invalid registrar pubkey");
return key;
}
}
}
}
@@ -0,0 +1 @@
0200a9de19b3551ace117973b80d632503bf2a55f0aa2490deb1474a280b675fa01bb2ccb5890faadcb213d3882fb21a7af13702526a569f7807b1c8b6963c0be402174553b456dddfc6908ecab1c101fe6ab21e2baa0617795b7d43a63482993fd500000300000000000000390000000000000006064170701074657374353539310274067265671050726f746f636f6c345348694e452d467265652d526567697374726174696f6e2d563100010008626f62406672656503a107bff3ce10be1d70dd18e74bc09967e4d6309ba50d5f1ddc8664125531b829acbae141bccaf0b22e1a94d34d0bc7361e526d0bfe12c89794bc9322966dd72543b92ff1095511476adc8369db6ddc933665a11978dda1404ee1066ca9559de2edfcd8b1b7a1823f56b827ddfa8a3682793e036141b526467ae346e220d08757d0a878a2f722562e6d3132ef9df04b1ab9e2f65d72bb0f48c17b7ada3e5a0acbc605c49fd774ff4d9ea789d8f6bffa719e9774cb86f62d11fd244121150956
@@ -0,0 +1,43 @@
package server.archive;
import server.archive.registration.*;
import blockchain.Ans104DataItem;
import blockchain.ShineProtocolTags;
import utils.crypto.Ed25519Util;
import java.util.Arrays;
import java.util.HexFormat;
/** Standalone test (no legacy signed fixture): certificate issue/verify for CURRENT App tag. */
public final class FreeRegistrationCertificateV1Check {
static final HexFormat HEX = HexFormat.of();
public static void main(String[] args) throws Exception {
byte[] seed = Ed25519Util.generatePrivateKeyFromString("TEST-only-reg-v1-check");
byte[] root = HEX.parseHex("03a107bff3ce10be1d70dd18e74bc09967e4d6309ba50d5f1ddc8664125531b8");
byte[] chain = HEX.parseHex("29acbae141bccaf0b22e1a94d34d0bc7361e526d0bfe12c89794bc9322966dd7");
byte[] client = HEX.parseHex("2543b92ff1095511476adc8369db6ddc933665a11978dda1404ee1066ca9559d");
try (var signer = new LocalRegistrarSigner(seed)) {
byte[] cert = FreeRegistrationCertificateV1.issue("SuperMan@free", root, chain, client,
" Alice.Example+Tag@Example.COM ", signer);
var item = new Ans104DataItem(cert);
if (!item.hasTag(ShineProtocolTags.APP_TAG_NAME, ShineProtocolTags.APP_TAG_VALUE))
throw new AssertionError("Current App tag missing");
var result = FreeRegistrationCertificateV1.verify(cert, signer.publicKey32());
if (!"SuperMan@free".equals(result.login()) || !Arrays.equals(result.rootKey(), root)
|| !Arrays.equals(result.blockchainKey(), chain) || !Arrays.equals(result.clientKey(), client))
throw new AssertionError("Certificate identity corrupted");
if (!Arrays.equals(result.emailSha256(), HEX.parseHex(
"cbc605c49fd774ff4d9ea789d8f6bffa719e9774cb86f62d11fd244121150956")))
throw new AssertionError("Email normalization differs");
byte[] bad = cert.clone(); bad[bad.length - 1] ^= 1;
try { FreeRegistrationCertificateV1.verify(bad, signer.publicKey32());
throw new AssertionError("Email bit flip accepted"); }
catch (IllegalArgumentException expected) {}
bad = cert.clone(); bad[bad.length - 40] ^= 1;
try { FreeRegistrationCertificateV1.verify(bad, signer.publicKey32());
throw new AssertionError("Inner signature tampering accepted"); }
catch (IllegalArgumentException expected) {}
}
System.out.println("PASS: current App=" + ShineProtocolTags.APP_TAG_VALUE
+ ", Java registrar inner+outer Ed25519, original case, email, tamper rejection");
}
}
@@ -0,0 +1,39 @@
package server.archive;
import server.archive.registration.*;
import javax.sql.DataSource;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HexFormat;
/** Только проверки без БД/сети; полное E2E требует PostgreSQL и Turbo. */
public final class FreeRegistrationWorkflowLocalCheck {
public static void main(String[] args) throws Exception {
var signer = new RegistrarSigner() {
public byte[] publicKey32() { return new byte[32]; }
public byte[] sign(byte[] message) { return new byte[64]; }
};
DataSource noDb = new DataSource() {
public java.sql.Connection getConnection() throws java.sql.SQLException { throw new java.sql.SQLException("No database in local test"); }
public java.sql.Connection getConnection(String u, String p) throws java.sql.SQLException { return getConnection(); }
public java.io.PrintWriter getLogWriter() {return null;}
public void setLogWriter(java.io.PrintWriter x) {}
public void setLoginTimeout(int x) {}
public int getLoginTimeout() {return 0;}
public java.util.logging.Logger getParentLogger() {return java.util.logging.Logger.getAnonymousLogger();}
public <T> T unwrap(Class<T> iface) throws java.sql.SQLException {throw new java.sql.SQLException("unsupported");}
public boolean isWrapperFor(Class<?> iface) {return false;}
};
var issuer = new FreeRegistrationIssuer(noDb, signer);
var importer = new VerifiedFreeRegistrationImporter();
var workflow = new FreeRegistrationWorkflow(issuer,
new FreeRegistrationPublisher(issuer, new TurboDataItemUploader(ArweaveBlocksConfig.load()), importer),
(email, code) -> { throw new AssertionError("No real email in an offline check"); });
try { workflow.confirm("unknown", "123456"); throw new AssertionError("Missing challenge accepted"); }
catch (IllegalArgumentException expected) { }
try { importer.importSigned(new byte[]{1,2,3}, VerifiedFreeRegistrationImporter.Provenance.TURBO_ACCEPTED);
throw new AssertionError("Invalid bytes accepted"); }
catch (IllegalArgumentException expected) { }
System.out.println("PASS: workflow missing challenge + reject invalid signed bytes");
}
}
@@ -0,0 +1,17 @@
package server.archive.registration;
/** Локальная проверка генератора и сверки кода без БД/HTTP. */
public final class RegistrationEmailCodeCheck {
public static void main(String[] args) {
for (int i=0; i<1000; ++i) {
String code = RegistrationEmailCode.generate();
if (!code.matches("[0-9]{6}")) throw new AssertionError("Wrong length");
byte[] hash = RegistrationEmailCode.hash("challenge-id", code);
if (!RegistrationEmailCode.matches(hash, "challenge-id", code)) throw new AssertionError("Cannot verify");
if (RegistrationEmailCode.matches(hash, "another-challenge", code)) throw new AssertionError("Challenge replay");
if (RegistrationEmailCode.matches(hash, "challenge-id", "1111")) throw new AssertionError("Old demo code accepted");
if (RegistrationEmailCode.matches(hash, "challenge-id", "bad")) throw new AssertionError("Bad code accepted");
}
System.out.println("PASS: email code generation and challenge binding");
}
}
@@ -0,0 +1,21 @@
package server.archive.registration;
/** Offline проверка часового TTL на уровне UX отдельно; bypass должен быть строго opt-in. */
public final class RegistrationEmailSettingsCheck {
public static void main(String[] args) {
byte[] digest = RegistrationEmailCode.hash("challenge", "123456");
var safe = new FreeRegistrationWorkflow(null, null, null, false);
var test = new FreeRegistrationWorkflow(null, null, null, true);
if (safe.isValidVerificationCode(digest, "challenge", "777777"))
throw new AssertionError("Cheat unexpectedly enabled by default");
if (!test.isValidVerificationCode(digest, "challenge", "777777"))
throw new AssertionError("Explicit test code not accepted");
if (!safe.isValidVerificationCode(digest, "challenge", "123456"))
throw new AssertionError("Real code rejected");
if (test.isValidVerificationCode(digest, "challenge", "1111"))
throw new AssertionError("Old demo code unexpectedly accepted");
if (test.isValidVerificationCode(digest, "challenge", "777778"))
throw new AssertionError("Invalid code unexpectedly accepted");
System.out.println("PASS: real code and opt-in test code");
}
}
@@ -9,7 +9,7 @@ package blockchain;
public final class ShineProtocolTags {
private ShineProtocolTags() {}
public static final String NAMESPACE = "test5591";
public static final String NAMESPACE = "test5592";
public static final String APP_TAG_NAME = "App";
public static final String APP_TAG_VALUE = NAMESPACE;
public static final String CHANNEL_TAG_NAME = "c";
@@ -78,8 +78,14 @@ public final class HeaderBody implements BodyRecord {
public HeaderBody check() {
if ((subType & 0xFFFF) != 0) throw new IllegalArgumentException("HeaderBody subType must be 0");
if (login == null || login.isBlank()) throw new IllegalArgumentException("Login is blank");
if (!login.matches("^[A-Za-z0-9_]+$")) throw new IllegalArgumentException("Login must match ^[A-Za-z0-9_]+$");
byte[] loginUtf8 = login.getBytes(StandardCharsets.UTF_8);
// В HEADER хранится неизменяемое написание зарегистрированного login@namespace.
// Namespace остаётся lowercase, регистр локальной части сохраняется байт-в-байт.
boolean legacyLogin = login.matches("^[A-Za-z0-9_]+$");
boolean namespacedLogin = loginUtf8.length <= 30 && login.matches("^[A-Za-z0-9_]+@[a-z0-9_]+$");
if (!legacyLogin && !namespacedLogin) {
throw new IllegalArgumentException("Login must be legacy [A-Za-z0-9_]+ or registered-case login@namespace (max 30 bytes)");
}
if (loginUtf8.length == 0 || loginUtf8.length > 255) throw new IllegalArgumentException("Login utf8 len must be 1..255");
requireNonZeroKey(initialBlockchainKey32);
return this;
@@ -98,6 +98,38 @@ final class TargetLoginFormatTest {
assertArrayEquals(INITIAL_KEY, parsed.initialBlockchainKey32);
}
@Test
void namespacedHeaderRoundTripAcceptsPaidAndFreeUsers() {
for (String login : new String[]{"alice@free", "AlexSmith@shine", "a_B@free", "abcdefghijklmnopqrstuvwxy@free"}) {
HeaderBody source = new HeaderBody(login, INITIAL_KEY);
HeaderBody parsed = new HeaderBody(HeaderBody.SUBTYPE_COMPAT, HeaderBody.VER, source.toBytes()).check();
assertEquals(login, parsed.login);
assertArrayEquals(INITIAL_KEY, parsed.initialBlockchainKey32);
}
}
@Test
void namespacedHeaderRejectsMalformedOrOversizedLogin() {
for (String login : new String[]{"alice@", "@shine", "alice@@free", "alice@FREE", "alice.free@shine", "abcdefghijklmnopqrstuvwxyz@free"}) {
assertThrows(IllegalArgumentException.class, () -> new HeaderBody(login, INITIAL_KEY), login);
}
}
@Test
void signedReferencesPreserveArbitraryLoginCaseWithoutServerSideCaseEnforcement() {
// Адресация не зависит от регистра, но блок сохраняет выбранные автором байты.
for (String login : new String[]{"AlexSmith@shine", "alexsmith@shine"}) {
TextReplyBody reply = new TextReplyBody(MsgSubType.TEXT_REPLY, login, 1, 42, HASH, "тест");
assertEquals(login, new TextReplyBody(MsgSubType.TEXT_REPLY, TextReplyBody.VER, reply.toBytes()).check().toLogin());
ReactionBody like = new ReactionBody(MsgSubType.REACTION_LIKE, login, 1, 42, HASH);
assertEquals(login, new ReactionBody(MsgSubType.REACTION_LIKE, ReactionBody.VER, like.toBytes()).check().toLogin());
ConnectionBody follow = new ConnectionBody(0, HASH, 1, MsgSubType.CONNECTION_FOLLOW, login, 1, 0, HASH);
assertEquals(login, new ConnectionBody(MsgSubType.CONNECTION_FOLLOW, ConnectionBody.VER, follow.toBytes()).check().toLogin());
}
}
private static byte[] hash(int seed) {
byte[] out = new byte[32];
Arrays.fill(out, (byte) seed);
@@ -23,9 +23,23 @@ public final class DatabaseInitializer {
public static final int SCHEMA_VERSION_1 = 1;
public static final int SCHEMA_VERSION_31 = 31;
public static final int SCHEMA_VERSION_32 = 32;
public static final int SCHEMA_VERSION_33 = 33;
public static final int SCHEMA_VERSION_34 = 34;
public static final int SCHEMA_VERSION_35 = 35;
public static final int SCHEMA_VERSION_36 = 36;
public static final int SCHEMA_VERSION_37 = 37;
public static final int SCHEMA_VERSION_38 = 38;
public static final int SCHEMA_VERSION_39 = 39;
public static final String POSTGRES_SCHEMA_RESOURCE = "postgres/schema_v1.sql";
public static final String POSTGRES_MIGRATION_V31_RESOURCE = "postgres/migration_v31.sql";
public static final String POSTGRES_MIGRATION_V32_RESOURCE = "postgres/migration_v32.sql";
public static final String POSTGRES_MIGRATION_V33_RESOURCE = "postgres/migration_v33.sql";
public static final String POSTGRES_MIGRATION_V34_RESOURCE = "postgres/migration_v34.sql";
public static final String POSTGRES_MIGRATION_V35_RESOURCE = "postgres/migration_v35.sql";
public static final String POSTGRES_MIGRATION_V36_RESOURCE = "postgres/migration_v36.sql";
public static final String POSTGRES_MIGRATION_V37_RESOURCE = "postgres/migration_v37.sql";
public static final String POSTGRES_MIGRATION_V38_RESOURCE = "postgres/migration_v38.sql";
public static final String POSTGRES_MIGRATION_V39_RESOURCE = "postgres/migration_v39.sql";
private DatabaseInitializer() {}
@@ -125,10 +139,39 @@ public final class DatabaseInitializer {
runSqlScript(conn, POSTGRES_MIGRATION_V32_RESOURCE);
currentVersion = readCurrentSchemaVersion(conn);
}
if (currentVersion != SCHEMA_VERSION_32) {
throw new SQLException(
"Unsupported SHiNE DB v2 schema version: expected 32, found " + currentVersion);
if (currentVersion == SCHEMA_VERSION_32) {
runSqlScript(conn, POSTGRES_MIGRATION_V33_RESOURCE);
currentVersion = readCurrentSchemaVersion(conn);
}
if (currentVersion == SCHEMA_VERSION_33) {
runSqlScript(conn, POSTGRES_MIGRATION_V34_RESOURCE);
currentVersion = readCurrentSchemaVersion(conn);
}
if (currentVersion == SCHEMA_VERSION_34) {
runSqlScript(conn, POSTGRES_MIGRATION_V35_RESOURCE);
currentVersion = readCurrentSchemaVersion(conn);
}
if (currentVersion == SCHEMA_VERSION_35) {
runSqlScript(conn, POSTGRES_MIGRATION_V36_RESOURCE);
currentVersion = readCurrentSchemaVersion(conn);
}
if (currentVersion == SCHEMA_VERSION_36) {
runSqlScript(conn, POSTGRES_MIGRATION_V37_RESOURCE);
currentVersion = readCurrentSchemaVersion(conn);
}
if (currentVersion == SCHEMA_VERSION_37) {
runSqlScript(conn, POSTGRES_MIGRATION_V38_RESOURCE);
currentVersion = readCurrentSchemaVersion(conn);
}
if (currentVersion == SCHEMA_VERSION_38) {
runSqlScript(conn, POSTGRES_MIGRATION_V39_RESOURCE);
currentVersion = readCurrentSchemaVersion(conn);
}
if (currentVersion != SCHEMA_VERSION_39) {
throw new SQLException(
"Unsupported SHiNE DB v2 schema version: expected 39, found " + currentVersion);
}
normalizeBlockchainStateKeysToBase64(conn);
}
}
@@ -208,6 +251,38 @@ public final class DatabaseInitializer {
}
}
/**
* blockchain_state — runtime-проекция: публичный blockchain key хранится
* строго как Base64(32). Ранний импорт free-регистраций ошибочно сохранял
* Base58, поэтому нормализация выполняется идемпотентно при старте.
*/
private static void normalizeBlockchainStateKeysToBase64(Connection conn) throws SQLException {
record StateKey(String login, int forkNumber, String key) {}
List<StateKey> entries = new ArrayList<>();
try (Statement st = conn.createStatement();
ResultSet rs = st.executeQuery("SELECT login, fork_number, blockchain_key FROM blockchain_state_store")) {
while (rs.next()) {
entries.add(new StateKey(rs.getString("login"), rs.getInt("fork_number"), rs.getString("blockchain_key")));
}
}
try (var update = conn.prepareStatement("""
UPDATE blockchain_state_store
SET blockchain_key = ?
WHERE login = ? AND fork_number = ?
""")) {
for (StateKey entry : entries) {
String normalized = KeyEncodingUtil.normalizeKeyToBase64_32(entry.key());
if (normalized == null || normalized.equals(entry.key())) continue;
update.setString(1, normalized);
update.setString(2, entry.login());
update.setInt(3, entry.forkNumber());
update.addBatch();
}
update.executeBatch();
}
}
private static void runSqlScript(Connection conn, String resourcePath) throws SQLException {
String sqlScript = loadClasspathResource(resourcePath);
List<String> statements = splitSqlStatements(sqlScript);
@@ -43,7 +43,7 @@ public final class BlockchainStateDAO {
last_block_hash,
updated_at_ms
FROM blockchain_state
WHERE login = ? AND fork_number = ?
WHERE LOWER(login) = LOWER(?) AND fork_number = ?
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
@@ -197,7 +197,7 @@ public final class BlockchainStateDAO {
file_size_bytes = file_size_bytes + ?,
updated_at_ms = ?
WHERE
login = ? AND fork_number = ?
LOWER(login) = LOWER(?) AND fork_number = ?
AND (file_size_bytes + ?) <= size_limit
""";
@@ -164,9 +164,9 @@ public final class ConnectionsStateDAO {
""";
try (PreparedStatement ps = c.prepareStatement(sql)) {
ps.setString(1, login);
ps.setString(1, login.trim().toLowerCase(java.util.Locale.ROOT));
ps.setInt(2, relType);
ps.setString(3, toLogin);
ps.setString(3, toLogin.trim().toLowerCase(java.util.Locale.ROOT));
if (toBlockNumber == null) ps.setNull(4, java.sql.Types.INTEGER); else ps.setInt(4, toBlockNumber);
ps.setBytes(5, toBlockHash);
ps.executeUpdate();
@@ -213,7 +213,7 @@ public final class CurrentUsersDAO {
String sql = """
SELECT su.login, coalesce(up.first_name, '') AS first_name,
coalesce(up.last_name, '') AS last_name, coalesce(up.ava_ar, '') AS ava_ar
FROM solana_user_pda_current su
FROM user_identity_current su
LEFT JOIN user_profile_state up ON lower(up.login) = lower(su.login)
WHERE (? IS NULL OR su.is_server = ?)
AND (
@@ -0,0 +1,58 @@
package shine.db.dao;
import shine.db.DbController;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/** Единая авторитетная проекция: FREE_CERT не притворяется Solana PDA. */
public final class RegistrationIdentityDAO {
public record ResolvedIdentity(String fullLogin, String rootKey, String blockchainKey,
String clientKey, String registrationSource, String registrationStatus,
String namespace, String accessServerLogin, boolean hasSolanaPda) {
public boolean isFree() { return "FREE_CERT".equals(registrationStatus); }
}
private static final RegistrationIdentityDAO INSTANCE = new RegistrationIdentityDAO();
public static RegistrationIdentityDAO getInstance() { return INSTANCE; }
private RegistrationIdentityDAO() {}
public ResolvedIdentity get(String login) throws SQLException {
try (Connection c = DbController.getInstance().getConnection()) { return get(c, login); }
}
public ResolvedIdentity get(Connection c, String login) throws SQLException {
if (login == null || login.isBlank()) return null;
try (PreparedStatement ps = c.prepareStatement("""
SELECT i.login, i.root_key, i.blockchain_key, i.client_key,
i.registration_source, i.registration_status, i.namespace,
i.solana_pda_address, n.default_server_login,
s.server_login AS actual_access_server
FROM user_identity_current i
LEFT JOIN shine_namespace_current n ON n.namespace=i.namespace
LEFT JOIN user_access_servers_current s ON s.user_login=i.login
WHERE i.normalized_login=LOWER(BTRIM(?))
ORDER BY s.server_login ASC
LIMIT 1
""")) {
ps.setString(1, login);
try (ResultSet rs = ps.executeQuery()) {
if (!rs.next()) return null;
boolean hasPda = rs.getString("solana_pda_address") != null;
String status = rs.getString("registration_status");
String server = "FREE_CERT".equals(status) ? rs.getString("default_server_login")
: rs.getString("actual_access_server");
if ("FREE_CERT".equals(status) && hasPda)
throw new SQLException("Inconsistent free user: Solana PDA must be absent");
if (!"FREE_CERT".equals(status) && !hasPda)
throw new SQLException("Inconsistent paid user: Solana PDA is missing");
return new ResolvedIdentity(rs.getString("login"), rs.getString("root_key"),
rs.getString("blockchain_key"), rs.getString("client_key"),
rs.getString("registration_source"), status, rs.getString("namespace"), server, hasPda);
}
}
}
public boolean isFreeCertificate(String login) throws SQLException {
ResolvedIdentity identity = get(login);
return identity != null && identity.isFree();
}
}
@@ -111,7 +111,7 @@ public final class SubscriptionsDAO {
FROM connections_state cs
JOIN channel_names_state cn ON LOWER(cn.owner_login)=LOWER(cs.to_login)
AND cn.channel_root_block_number=cs.to_block_number AND cn.channel_root_block_hash=cs.to_block_hash
WHERE cs.login = ? AND cs.rel_type = ?
WHERE LOWER(cs.login) = LOWER(?) AND cs.rel_type = ?
UNION
@@ -46,26 +46,28 @@ public final class UserAccessServersCurrentDAO {
public UserAccessServerRouteEntry findPrimaryByUserLogin(String userLogin) throws SQLException {
String sql = """
SELECT
u.login AS user_login,
i.login AS user_login,
s.login AS server_login,
s.server_address AS server_url,
s.client_key AS server_client_key
FROM solana_user_pda_current u
FROM user_identity_current i
LEFT JOIN solana_user_pda_current u ON u.login = i.login
LEFT JOIN shine_namespace_current ns ON ns.namespace = i.namespace
CROSS JOIN LATERAL (
SELECT BTRIM(a.login_value) AS server_login
FROM jsonb_array_elements_text(
CASE
WHEN BTRIM(COALESCE(u.access_servers_json, '')) = '' THEN '[]'::jsonb
ELSE u.access_servers_json::jsonb
END
) WITH ORDINALITY AS a(login_value, ord)
WHERE a.ord = 1
SELECT CASE WHEN i.registration_status = 'FREE_CERT'
THEN ns.default_server_login
ELSE (SELECT BTRIM(a.login_value)
FROM jsonb_array_elements_text(
COALESCE(NULLIF(u.access_servers_json, ''), '[]')::jsonb)
WITH ORDINALITY AS a(login_value, ord)
WHERE a.ord = 1)
END AS server_login
) primary_access
JOIN solana_user_pda_current s
ON s.normalized_login = LOWER(primary_access.server_login)
AND s.is_server = TRUE
AND BTRIM(COALESCE(s.server_address, '')) <> ''
WHERE u.normalized_login = LOWER(BTRIM(?))
WHERE i.normalized_login = LOWER(BTRIM(?))
LIMIT 1
""";
try (Connection c = db.getConnection();
@@ -18,7 +18,7 @@ public final class CurrentUsersSql {
current_users.blockchain_key AS blockchain_key,
current_users.client_key AS client_key,
current_users.is_server AS is_server
FROM solana_user_pda_current current_users
FROM user_identity_current current_users
) %s
""".formatted(alias);
}
@@ -0,0 +1,213 @@
-- SHiNE DB v33: общий индекс идентичностей, namespace и сертификаты.
-- ТОЛЬКО dev/test до проверки всей серверной авторизации.
BEGIN;
CREATE TABLE user_identity_current (
login TEXT PRIMARY KEY,
normalized_login TEXT NOT NULL UNIQUE,
namespace TEXT,
registration_source TEXT NOT NULL CHECK (registration_source IN ('SOLANA', 'ARWEAVE')),
registration_status TEXT NOT NULL CHECK (registration_status IN ('PAID_DIRECT', 'FREE_CERT', 'PAID_UPGRADED')),
solana_pda_address TEXT UNIQUE,
free_data_item_id TEXT UNIQUE,
root_key TEXT NOT NULL,
client_key TEXT NOT NULL,
blockchain_key TEXT NOT NULL,
blockchain_name TEXT NOT NULL,
is_server BOOLEAN NOT NULL DEFAULT FALSE,
registered_at_ms BIGINT NOT NULL,
updated_at_ms BIGINT NOT NULL,
CHECK ((registration_status = 'FREE_CERT' AND solana_pda_address IS NULL AND free_data_item_id IS NOT NULL)
OR (registration_status <> 'FREE_CERT' AND solana_pda_address IS NOT NULL))
);
CREATE INDEX idx_user_identity_namespace ON user_identity_current(namespace);
INSERT INTO user_identity_current (
login, normalized_login, namespace, registration_source, registration_status,
solana_pda_address, root_key, client_key, blockchain_key, blockchain_name,
is_server, registered_at_ms, updated_at_ms
)
SELECT login, normalized_login,
CASE WHEN position('@' in login) > 0 THEN split_part(login, '@', 2) ELSE NULL END,
'SOLANA', 'PAID_DIRECT', pda_address, root_key, client_key, blockchain_key,
blockchain_name, is_server, created_at_ms, updated_at_ms
FROM solana_user_pda_current
ON CONFLICT (login) DO NOTHING;
CREATE TABLE shine_namespace_current (
namespace TEXT PRIMARY KEY,
pda_address TEXT NOT NULL UNIQUE,
namespace_type SMALLINT NOT NULL CHECK(namespace_type IN (1,2)),
min_localpart_len SMALLINT NOT NULL CHECK (min_localpart_len BETWEEN 1 AND 30),
registration_fee_lamports NUMERIC(20,0) NOT NULL CHECK (registration_fee_lamports >= 0),
registrar_pubkey TEXT,
default_server_login TEXT,
slot BIGINT NOT NULL,
last_tx_signature TEXT NOT NULL DEFAULT '',
raw_data_base64 TEXT NOT NULL,
CHECK ((namespace_type = 1 AND registrar_pubkey IS NULL AND default_server_login IS NULL)
OR (namespace_type = 2 AND registrar_pubkey IS NOT NULL AND default_server_login IS NOT NULL))
);
CREATE TABLE free_registration_certificate (
data_item_id TEXT PRIMARY KEY,
login TEXT NOT NULL UNIQUE REFERENCES user_identity_current(login),
namespace TEXT NOT NULL REFERENCES shine_namespace_current(namespace),
email_sha256 BYTEA NOT NULL UNIQUE CHECK (octet_length(email_sha256) = 32),
inner_signature BYTEA NOT NULL CHECK (octet_length(inner_signature) = 64),
raw_signed_data_item BYTEA NOT NULL,
publication_status TEXT NOT NULL CHECK (publication_status IN ('TURBO_ACCEPTED','ARWEAVE_SEEN','ARWEAVE_CONFIRMED')),
registered_at_ms BIGINT NOT NULL,
last_seen_at_ms BIGINT NOT NULL
);
CREATE INDEX idx_free_registration_namespace ON free_registration_certificate(namespace);
-- Существующие объекты (в том числе десятки FK) должны ссылаться на логическую
-- идентичность, иначе бесплатный пользователь не сможет иметь профиль/связи/каналы.
-- Воссоздаём существующие FK с теми же ON DELETE/UPDATE и deferrable-настройками.
DO $$
DECLARE
item RECORD;
definition TEXT;
BEGIN
FOR item IN SELECT c.conname, c.conrelid::regclass AS child_table,
pg_get_constraintdef(c.oid) AS definition
FROM pg_constraint c
WHERE c.contype = 'f' AND c.confrelid = 'solana_user_pda_current'::regclass
LOOP
definition := replace(item.definition,
'REFERENCES solana_user_pda_current(', 'REFERENCES user_identity_current(');
IF definition = item.definition THEN
RAISE EXCEPTION 'Unexpected FK expression: %', item.definition;
END IF;
EXECUTE format('ALTER TABLE %s DROP CONSTRAINT %I', item.child_table, item.conname);
EXECUTE format('ALTER TABLE %s ADD CONSTRAINT %I %s', item.child_table, item.conname, definition);
END LOOP;
END $$;
-- Любое поступившее из Solana состояние дополняет существующую идентичность.
-- Бесплатный → платный допускается ТОЛЬКО при совпадении всех публичных ключей;
-- старые on-chain key rotations разрешены, если статус уже платный.
CREATE OR REPLACE FUNCTION shine_sync_identity_from_solana()
RETURNS TRIGGER LANGUAGE plpgsql AS $$
DECLARE old_user user_identity_current%ROWTYPE;
BEGIN
-- Если PostgreSQL получил старую запись из replay, она не должна затереть
-- уже принятую более новую логическую идентичность в BEFORE INSERT.
IF TG_OP = 'INSERT' AND EXISTS (
SELECT 1 FROM solana_user_pda_current prior
WHERE prior.pda_address = NEW.pda_address AND prior.record_number > NEW.record_number
) THEN
RETURN NEW;
END IF;
SELECT * INTO old_user FROM user_identity_current
WHERE normalized_login = NEW.normalized_login FOR UPDATE;
IF FOUND AND old_user.registration_status = 'FREE_CERT' AND
(old_user.root_key <> NEW.root_key OR old_user.client_key <> NEW.client_key OR old_user.blockchain_key <> NEW.blockchain_key) THEN
RAISE EXCEPTION 'Free certificate keys differ from Solana upgrade for %', NEW.login;
END IF;
IF FOUND AND old_user.solana_pda_address IS NOT NULL AND old_user.solana_pda_address <> NEW.pda_address THEN
RAISE EXCEPTION 'Duplicate on-chain identity for %', NEW.login;
END IF;
INSERT INTO user_identity_current (
login, normalized_login, namespace, registration_source, registration_status,
solana_pda_address, free_data_item_id, root_key, client_key, blockchain_key,
blockchain_name, is_server, registered_at_ms, updated_at_ms)
VALUES (NEW.login, NEW.normalized_login,
CASE WHEN position('@' in NEW.login) > 0 THEN split_part(NEW.login,'@',2) ELSE NULL END,
'SOLANA', CASE WHEN old_user.free_data_item_id IS NOT NULL THEN 'PAID_UPGRADED' ELSE 'PAID_DIRECT' END,
NEW.pda_address, old_user.free_data_item_id, NEW.root_key, NEW.client_key,
NEW.blockchain_key, NEW.blockchain_name, NEW.is_server,
COALESCE(old_user.registered_at_ms, NEW.created_at_ms), NEW.updated_at_ms)
ON CONFLICT (login) DO UPDATE SET
registration_source='SOLANA',
registration_status=EXCLUDED.registration_status,
solana_pda_address=EXCLUDED.solana_pda_address,
root_key=EXCLUDED.root_key, client_key=EXCLUDED.client_key,
blockchain_key=EXCLUDED.blockchain_key, blockchain_name=EXCLUDED.blockchain_name,
is_server=EXCLUDED.is_server, updated_at_ms=EXCLUDED.updated_at_ms;
RETURN NEW;
END $$;
CREATE TRIGGER trg_sync_identity_from_solana
BEFORE INSERT OR UPDATE ON solana_user_pda_current
FOR EACH ROW EXECUTE FUNCTION shine_sync_identity_from_solana();
-- Free namespace: сервер доступа задаётся namespace, а не клиентским полем.
-- Реальный сервер должен иметь on-chain PDA и открытый адрес.
CREATE OR REPLACE FUNCTION shine_refresh_user_access_servers_for_user(p_user_login TEXT)
RETURNS VOID LANGUAGE plpgsql AS $$
BEGIN
IF p_user_login IS NULL OR btrim(p_user_login) = '' THEN RETURN; END IF;
DELETE FROM user_access_servers_current WHERE lower(user_login) = lower(p_user_login);
INSERT INTO user_access_servers_current (
user_login, server_login, server_url, server_client_key, user_record_number,
user_updated_at_ms, server_record_number, server_updated_at_ms, refreshed_at_ms)
SELECT i.login, srv.login, srv.server_address, srv.client_key,
COALESCE(u.record_number, 0), i.updated_at_ms,
srv.record_number, srv.updated_at_ms,
CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT)
FROM user_identity_current i
LEFT JOIN solana_user_pda_current u ON u.login = i.login
LEFT JOIN shine_namespace_current ns ON ns.namespace = i.namespace
CROSS JOIN LATERAL (
SELECT CASE WHEN i.registration_status = 'FREE_CERT' THEN ns.default_server_login
ELSE (SELECT value FROM jsonb_array_elements_text(
COALESCE(NULLIF(u.access_servers_json, ''), '[]')::jsonb)
WITH ORDINALITY AS a(value, position) WHERE position=1) END AS login
) effective
JOIN solana_user_pda_current srv
ON lower(srv.login) = lower(effective.login) AND srv.is_server = true
AND btrim(coalesce(srv.server_address, '')) <> ''
WHERE lower(i.login) = lower(p_user_login)
ON CONFLICT (user_login, server_login) DO UPDATE SET
server_url=EXCLUDED.server_url, server_client_key=EXCLUDED.server_client_key,
user_record_number=EXCLUDED.user_record_number,
user_updated_at_ms=EXCLUDED.user_updated_at_ms,
server_record_number=EXCLUDED.server_record_number,
server_updated_at_ms=EXCLUDED.server_updated_at_ms,
refreshed_at_ms=EXCLUDED.refreshed_at_ms;
END $$;
CREATE OR REPLACE FUNCTION shine_refresh_user_access_servers_for_server(p_server_login TEXT)
RETURNS VOID LANGUAGE plpgsql AS $$
DECLARE u RECORD;
BEGIN
IF p_server_login IS NULL OR btrim(p_server_login) = '' THEN RETURN; END IF;
DELETE FROM user_access_servers_current WHERE lower(server_login) = lower(p_server_login);
FOR u IN
SELECT i.login FROM user_identity_current i
LEFT JOIN solana_user_pda_current p ON p.login=i.login
LEFT JOIN shine_namespace_current ns ON ns.namespace=i.namespace
WHERE lower(p_server_login) = lower(
CASE WHEN i.registration_status='FREE_CERT' THEN ns.default_server_login
ELSE (SELECT value FROM jsonb_array_elements_text(
COALESCE(NULLIF(p.access_servers_json,''),'[]')::jsonb)
WITH ORDINALITY AS a(value, position) WHERE position=1) END)
LOOP PERFORM shine_refresh_user_access_servers_for_user(u.login); END LOOP;
END $$;
CREATE OR REPLACE FUNCTION shine_refresh_user_access_servers_all()
RETURNS VOID LANGUAGE plpgsql AS $$
DECLARE u RECORD;
BEGIN
TRUNCATE TABLE user_access_servers_current;
FOR u IN SELECT login FROM user_identity_current LOOP
PERFORM shine_refresh_user_access_servers_for_user(u.login);
END LOOP;
END $$;
CREATE OR REPLACE FUNCTION shine_refresh_free_routing_from_identity()
RETURNS TRIGGER LANGUAGE plpgsql AS $$
BEGIN
IF NEW.registration_status = 'FREE_CERT' THEN
PERFORM shine_refresh_user_access_servers_for_user(NEW.login);
END IF;
RETURN NEW;
END $$;
CREATE TRIGGER trg_refresh_free_routing_from_identity
AFTER INSERT OR UPDATE ON user_identity_current
FOR EACH ROW EXECUTE FUNCTION shine_refresh_free_routing_from_identity();
UPDATE db_schema_version SET schema_version=33,
updated_at_ms=CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT) WHERE id=1;
COMMIT;
@@ -0,0 +1,12 @@
-- SHiNE v34. Отдельный checkpoint Arweave сертификатов, не смешивать с блоками.
BEGIN;
CREATE TABLE IF NOT EXISTS free_registration_arweave_sync_state (
id SMALLINT PRIMARY KEY CHECK (id=1),
last_block_height BIGINT NOT NULL DEFAULT 0 CHECK (last_block_height>=0),
updated_at_ms BIGINT NOT NULL DEFAULT 0
);
INSERT INTO free_registration_arweave_sync_state (id,last_block_height,updated_at_ms)
VALUES (1,0,0) ON CONFLICT (id) DO NOTHING;
UPDATE db_schema_version SET schema_version=34,
updated_at_ms=CAST(EXTRACT(EPOCH FROM clock_timestamp())*1000 AS BIGINT) WHERE id=1;
COMMIT;
@@ -0,0 +1,62 @@
-- v35: один полноценный статус для всех зарегистрированных в Solana.
-- Старые регистрационные сертификаты Arweave и дата исходной регистрации сохраняются.
BEGIN;
-- Сначала снимаем старое ограничение, затем переводим существующие строки.
ALTER TABLE user_identity_current
DROP CONSTRAINT user_identity_current_registration_status_check;
UPDATE user_identity_current
SET registration_status = 'PAID'
WHERE registration_status IN ('PAID_DIRECT', 'PAID_UPGRADED');
ALTER TABLE user_identity_current
ADD CONSTRAINT user_identity_current_registration_status_check
CHECK (registration_status IN ('FREE_CERT', 'PAID'));
-- Важнее миграции существующих строк: при следующих Solana sync/upsert
-- и обычный платный, и ранее бесплатный пользователь получают тот же PAID.
CREATE OR REPLACE FUNCTION shine_sync_identity_from_solana()
RETURNS TRIGGER LANGUAGE plpgsql AS $$
DECLARE old_user user_identity_current%ROWTYPE;
BEGIN
-- Если PostgreSQL получил старую запись из replay, она не должна затереть
-- уже принятую более новую логическую идентичность в BEFORE INSERT.
IF TG_OP = 'INSERT' AND EXISTS (
SELECT 1 FROM solana_user_pda_current prior
WHERE prior.pda_address = NEW.pda_address AND prior.record_number > NEW.record_number
) THEN
RETURN NEW;
END IF;
SELECT * INTO old_user FROM user_identity_current
WHERE normalized_login = NEW.normalized_login FOR UPDATE;
IF FOUND AND old_user.registration_status = 'FREE_CERT' AND
(old_user.root_key <> NEW.root_key OR old_user.client_key <> NEW.client_key OR old_user.blockchain_key <> NEW.blockchain_key) THEN
RAISE EXCEPTION 'Free certificate keys differ from Solana upgrade for %', NEW.login;
END IF;
IF FOUND AND old_user.solana_pda_address IS NOT NULL AND old_user.solana_pda_address <> NEW.pda_address THEN
RAISE EXCEPTION 'Duplicate on-chain identity for %', NEW.login;
END IF;
INSERT INTO user_identity_current (
login, normalized_login, namespace, registration_source, registration_status,
solana_pda_address, free_data_item_id, root_key, client_key, blockchain_key,
blockchain_name, is_server, registered_at_ms, updated_at_ms)
VALUES (NEW.login, NEW.normalized_login,
CASE WHEN position('@' in NEW.login) > 0 THEN split_part(NEW.login,'@',2) ELSE NULL END,
'SOLANA', 'PAID',
NEW.pda_address, old_user.free_data_item_id, NEW.root_key, NEW.client_key,
NEW.blockchain_key, NEW.blockchain_name, NEW.is_server,
COALESCE(old_user.registered_at_ms, NEW.created_at_ms), NEW.updated_at_ms)
ON CONFLICT (login) DO UPDATE SET
registration_source='SOLANA',
registration_status=EXCLUDED.registration_status,
solana_pda_address=EXCLUDED.solana_pda_address,
root_key=EXCLUDED.root_key, client_key=EXCLUDED.client_key,
blockchain_key=EXCLUDED.blockchain_key, blockchain_name=EXCLUDED.blockchain_name,
is_server=EXCLUDED.is_server, updated_at_ms=EXCLUDED.updated_at_ms;
RETURN NEW;
END $$;
UPDATE db_schema_version
SET schema_version=35,
updated_at_ms=CAST(EXTRACT(EPOCH FROM clock_timestamp())*1000 AS BIGINT)
WHERE id=1;
COMMIT;
@@ -0,0 +1,66 @@
-- v36: регистрационная запись хранит исходный регистр; все ссылки FK
-- приводятся к её точному login. Исторические строки не мигрируются.
-- На новой базе исходные имена PDA/сертификатов и FK согласованы.
BEGIN;
CREATE OR REPLACE FUNCTION shine_canonicalize_identity_fk_login()
RETURNS TRIGGER LANGUAGE plpgsql AS $$
DECLARE
field_name TEXT := TG_ARGV[0];
requested_login TEXT;
canonical_login TEXT;
BEGIN
requested_login := to_jsonb(NEW)->>field_name;
IF requested_login IS NULL OR btrim(requested_login) = '' THEN
RETURN NEW;
END IF;
SELECT i.login INTO canonical_login
FROM user_identity_current i
WHERE i.normalized_login = lower(btrim(requested_login))
LIMIT 1;
IF canonical_login IS NOT NULL THEN
-- Меняем только проекцию/связь в SQL, никогда не байты подписанного блока.
NEW := jsonb_populate_record(NEW, jsonb_build_object(field_name, canonical_login));
END IF;
RETURN NEW;
END $$;
DO $$
DECLARE
tab_name TEXT;
col_name TEXT;
spec TEXT;
trigger_name TEXT;
BEGIN
FOREACH spec IN ARRAY ARRAY[
'user_access_servers_current:user_login',
'user_access_servers_current:server_login',
'active_sessions:login',
'esp_pairing_settings:login',
'esp_pairing_requests:login',
'users_params:login',
'user_settings:login',
'channel_read_state:viewer_login',
'test_free_avatar_uploads:login',
-- blockchain_state — compatibility view; trigger может существовать
-- только на физической таблице хранения.
'blockchain_state_store:login',
'user_stats_state:login',
'user_push_tokens:login',
'key_rotation_sessions:login'
] LOOP
tab_name := split_part(spec, ':', 1);
col_name := split_part(spec, ':', 2);
trigger_name := 'trg_canonical_identity_' || tab_name || '_' || col_name;
EXECUTE format('DROP TRIGGER IF EXISTS %I ON %I', trigger_name, tab_name);
EXECUTE format(
'CREATE TRIGGER %I BEFORE INSERT OR UPDATE OF %I ON %I FOR EACH ROW EXECUTE FUNCTION shine_canonicalize_identity_fk_login(%L)',
trigger_name, col_name, tab_name, col_name
);
END LOOP;
END $$;
UPDATE db_schema_version SET schema_version = 36,
updated_at_ms = CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT)
WHERE id = 1;
COMMIT;
@@ -0,0 +1,70 @@
-- v37: оригинальный регистр имени фиксируется при первой регистрации.
-- Нормализованное имя остаётся единственным ключом уникальности.
BEGIN;
CREATE OR REPLACE FUNCTION shine_identity_login_immutable()
RETURNS TRIGGER LANGUAGE plpgsql AS $$
BEGIN
IF TG_OP = 'UPDATE' AND (NEW.login IS DISTINCT FROM OLD.login
OR NEW.normalized_login IS DISTINCT FROM OLD.normalized_login) THEN
RAISE EXCEPTION 'Registered login spelling is immutable: %', OLD.login;
END IF;
IF NEW.normalized_login IS DISTINCT FROM lower(btrim(NEW.login)) THEN
RAISE EXCEPTION 'normalized_login must match registered login: %', NEW.login;
END IF;
RETURN NEW;
END $$;
DROP TRIGGER IF EXISTS trg_identity_login_immutable ON user_identity_current;
CREATE TRIGGER trg_identity_login_immutable
BEFORE INSERT OR UPDATE ON user_identity_current
FOR EACH ROW EXECUTE FUNCTION shine_identity_login_immutable();
-- FREE_CERT -> Solana: имя должно совпадать побайтно, включая регистр.
-- Источником имени остаётся первая регистрация, а не очередная синхронизация.
CREATE OR REPLACE FUNCTION shine_sync_identity_from_solana()
RETURNS TRIGGER LANGUAGE plpgsql AS $$
DECLARE old_user user_identity_current%ROWTYPE;
BEGIN
IF TG_OP = 'INSERT' AND EXISTS (
SELECT 1 FROM solana_user_pda_current prior
WHERE prior.pda_address = NEW.pda_address AND prior.record_number > NEW.record_number
) THEN
RETURN NEW;
END IF;
SELECT * INTO old_user FROM user_identity_current
WHERE normalized_login = NEW.normalized_login FOR UPDATE;
IF FOUND AND old_user.login <> NEW.login THEN
RAISE EXCEPTION 'Registered login case mismatch: % vs %', old_user.login, NEW.login;
END IF;
IF FOUND AND old_user.registration_status = 'FREE_CERT' AND
(old_user.root_key <> NEW.root_key OR old_user.client_key <> NEW.client_key OR old_user.blockchain_key <> NEW.blockchain_key) THEN
RAISE EXCEPTION 'Free certificate keys differ from Solana upgrade for %', NEW.login;
END IF;
IF FOUND AND old_user.solana_pda_address IS NOT NULL AND old_user.solana_pda_address <> NEW.pda_address THEN
RAISE EXCEPTION 'Duplicate on-chain identity for %', NEW.login;
END IF;
INSERT INTO user_identity_current (
login, normalized_login, namespace, registration_source, registration_status,
solana_pda_address, free_data_item_id, root_key, client_key, blockchain_key,
blockchain_name, is_server, registered_at_ms, updated_at_ms)
VALUES (NEW.login, NEW.normalized_login,
CASE WHEN position('@' in NEW.login) > 0 THEN split_part(NEW.login,'@',2) ELSE NULL END,
'SOLANA', 'PAID',
NEW.pda_address, old_user.free_data_item_id, NEW.root_key, NEW.client_key,
NEW.blockchain_key, NEW.blockchain_name, NEW.is_server,
COALESCE(old_user.registered_at_ms, NEW.created_at_ms), NEW.updated_at_ms)
ON CONFLICT (login) DO UPDATE SET
registration_source='SOLANA',
registration_status=EXCLUDED.registration_status,
solana_pda_address=EXCLUDED.solana_pda_address,
root_key=EXCLUDED.root_key, client_key=EXCLUDED.client_key,
blockchain_key=EXCLUDED.blockchain_key, blockchain_name=EXCLUDED.blockchain_name,
is_server=EXCLUDED.is_server, updated_at_ms=EXCLUDED.updated_at_ms;
RETURN NEW;
END $$;
UPDATE db_schema_version SET schema_version = 37,
updated_at_ms = CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT)
WHERE id = 1;
COMMIT;
@@ -0,0 +1,11 @@
-- v38: blockchain_state_store.blockchain_key — runtime Base64(32).
-- Исторические Base58-значения нормализуются Java bootstrapper-ом,
-- поскольку PostgreSQL не содержит встроенного корректного Base58 decoder.
BEGIN;
UPDATE db_schema_version
SET schema_version = 38,
updated_at_ms = CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT)
WHERE id = 1;
COMMIT;
@@ -0,0 +1,11 @@
-- SHiNE DB v39: допускает временный opt-in на повторное использование email
-- для free-регистрации. По умолчанию это всё равно запрещено проверками runtime.
BEGIN;
ALTER TABLE free_registration_certificate
DROP CONSTRAINT IF EXISTS free_registration_certificate_email_sha256_key;
CREATE INDEX IF NOT EXISTS idx_free_registration_email_sha256
ON free_registration_certificate(email_sha256);
UPDATE db_schema_version SET schema_version = 39 WHERE id = 1;
COMMIT;
@@ -2334,11 +2334,15 @@ CREATE INDEX idx_message_views_target_v29 ON message_views_state(to_login,to_blo
CREATE OR REPLACE FUNCTION shine_refresh_user_stats(p_login TEXT) RETURNS VOID LANGUAGE plpgsql AS $$
DECLARE v_now BIGINT:=CAST(EXTRACT(EPOCH FROM clock_timestamp())*1000 AS BIGINT);
v_canonical_login TEXT;
BEGIN
IF p_login IS NULL OR btrim(p_login)='' THEN RETURN; END IF;
-- В FK остаётся исходный регистр владельца, но поиск/сопоставления регистронезависимы.
SELECT login INTO v_canonical_login FROM user_identity_current WHERE normalized_login=lower(btrim(p_login)) LIMIT 1;
IF v_canonical_login IS NULL THEN RETURN; END IF;
INSERT INTO user_stats_state(login,owned_public_channels_count,following_users_count,following_channels_count,close_friends_count,friends_count,
primary_confirmations_received_count,primary_confirmations_given_count,shine_confirmations_received_count,shine_confirmations_given_count,updated_at_ms)
SELECT p_login,
SELECT v_canonical_login,
(SELECT COUNT(*)::INT FROM channel_names_state cn WHERE LOWER(cn.owner_login)=LOWER(p_login) AND cn.channel_type_code=1 AND NOT cn.is_deleted),
(SELECT COUNT(DISTINCT LOWER(cs.to_login))::INT FROM connections_state cs WHERE LOWER(cs.login)=LOWER(p_login) AND cs.rel_type=30 AND cs.to_block_number=0),
(SELECT COUNT(*)::INT FROM connections_state cs JOIN channel_names_state cn ON LOWER(cn.owner_login)=LOWER(cs.to_login) AND cn.channel_root_block_number=cs.to_block_number AND cn.channel_root_block_hash=cs.to_block_hash WHERE LOWER(cs.login)=LOWER(p_login) AND cs.rel_type=30 AND cn.channel_type_code=1 AND NOT cn.is_deleted),
@@ -2485,15 +2489,15 @@ DECLARE positive_rel_type INTEGER; channel_bch TEXT;
BEGIN
IF NEW.msg_type<>3 OR NEW.to_login IS NULL OR NEW.to_block_number IS NULL OR NEW.to_block_hash IS NULL THEN RETURN NEW; END IF;
IF NEW.msg_sub_type IN (10,14,20,30,40,50,52,54,60,70,74,80) THEN
DELETE FROM connections_state WHERE login=NEW.login AND rel_type=NEW.msg_sub_type AND to_login=NEW.to_login AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash;
DELETE FROM connections_state WHERE login=lower(NEW.login) AND rel_type=NEW.msg_sub_type AND to_login=lower(NEW.to_login) AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash;
INSERT INTO connections_state(login,rel_type,to_login,to_block_number,to_block_hash)
VALUES(NEW.login,NEW.msg_sub_type,NEW.to_login,NEW.to_block_number,NEW.to_block_hash);
VALUES(lower(NEW.login),NEW.msg_sub_type,lower(NEW.to_login),NEW.to_block_number,NEW.to_block_hash);
ELSE
positive_rel_type := CASE NEW.msg_sub_type WHEN 11 THEN 10 WHEN 15 THEN 14 WHEN 21 THEN 20 WHEN 31 THEN 30 WHEN 41 THEN 40 WHEN 51 THEN 50 WHEN 53 THEN 52 WHEN 55 THEN 54 WHEN 61 THEN 60 WHEN 71 THEN 70 WHEN 75 THEN 74 WHEN 81 THEN 80 ELSE NULL END;
IF positive_rel_type IS NOT NULL THEN DELETE FROM connections_state WHERE login=NEW.login AND rel_type=positive_rel_type AND to_login=NEW.to_login AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash; END IF;
IF positive_rel_type IS NOT NULL THEN DELETE FROM connections_state WHERE login=lower(NEW.login) AND rel_type=positive_rel_type AND to_login=lower(NEW.to_login) AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash; END IF;
END IF;
PERFORM shine_refresh_user_stats(NEW.login);
PERFORM shine_refresh_user_stats(NEW.to_login);
PERFORM shine_refresh_user_stats(lower(NEW.login));
PERFORM shine_refresh_user_stats(lower(NEW.to_login));
IF NEW.msg_sub_type IN (30,31) AND NEW.to_block_number>0 THEN
SELECT owner_bch_name INTO channel_bch FROM channel_names_state WHERE LOWER(owner_login)=LOWER(NEW.to_login) AND channel_root_block_number=NEW.to_block_number AND channel_root_block_hash=NEW.to_block_hash LIMIT 1;
IF channel_bch IS NOT NULL THEN PERFORM shine_refresh_channel_follow_stats(channel_bch,NEW.to_block_number,NEW.to_block_hash); END IF;
@@ -2506,22 +2510,22 @@ DECLARE previous_sub_type INTEGER;
BEGIN
IF NEW.msg_type<>2 OR NEW.msg_sub_type NOT IN (1,2) THEN RETURN NEW; END IF;
IF NEW.to_login IS NULL OR NEW.to_block_number IS NULL OR NEW.to_block_hash IS NULL THEN RETURN NEW; END IF;
INSERT INTO message_stats(to_login,to_block_number,to_block_hash) VALUES(NEW.to_login,NEW.to_block_number,NEW.to_block_hash)
INSERT INTO message_stats(to_login,to_block_number,to_block_hash) VALUES(lower(NEW.to_login),NEW.to_block_number,NEW.to_block_hash)
ON CONFLICT(to_login,to_block_number,to_block_hash) DO NOTHING;
SELECT last_sub_type INTO previous_sub_type FROM reactions_state WHERE from_login=NEW.login AND reaction_type=1 AND to_login=NEW.to_login AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash LIMIT 1;
SELECT last_sub_type INTO previous_sub_type FROM reactions_state WHERE from_login=lower(NEW.login) AND reaction_type=1 AND to_login=lower(NEW.to_login) AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash LIMIT 1;
IF NEW.msg_sub_type=1 AND previous_sub_type IS DISTINCT FROM 1 THEN
UPDATE message_stats SET likes_count=likes_count+1,
primary_likes_count=primary_likes_count+CASE WHEN shine_is_primary(NEW.login) THEN 1 ELSE 0 END,
shining_likes_count=shining_likes_count+CASE WHEN shine_is_primary(NEW.login) AND shine_is_shining(NEW.login) THEN 1 ELSE 0 END
WHERE to_login=NEW.to_login AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash;
WHERE to_login=lower(NEW.to_login) AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash;
ELSIF NEW.msg_sub_type=2 AND previous_sub_type=1 THEN
UPDATE message_stats SET likes_count=GREATEST(0,likes_count-1),
primary_likes_count=GREATEST(0,primary_likes_count-CASE WHEN shine_is_primary(NEW.login) THEN 1 ELSE 0 END),
shining_likes_count=GREATEST(0,shining_likes_count-CASE WHEN shine_is_primary(NEW.login) AND shine_is_shining(NEW.login) THEN 1 ELSE 0 END)
WHERE to_login=NEW.to_login AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash;
WHERE to_login=lower(NEW.to_login) AND to_block_number=NEW.to_block_number AND to_block_hash=NEW.to_block_hash;
END IF;
INSERT INTO reactions_state(from_login,reaction_type,to_login,to_block_number,to_block_hash,last_sub_type)
VALUES(NEW.login,1,NEW.to_login,NEW.to_block_number,NEW.to_block_hash,NEW.msg_sub_type)
VALUES(lower(NEW.login),1,lower(NEW.to_login),NEW.to_block_number,NEW.to_block_hash,NEW.msg_sub_type)
ON CONFLICT(from_login,reaction_type,to_login,to_block_number,to_block_hash) DO UPDATE SET last_sub_type=EXCLUDED.last_sub_type;
RETURN NEW;
END $$;
@@ -2532,7 +2536,7 @@ BEGIN
IF NEW.msg_type<>1 OR NEW.msg_sub_type<>20 THEN RETURN NEW; END IF;
IF NEW.to_login IS NULL OR NEW.to_block_number IS NULL OR NEW.to_block_hash IS NULL THEN RETURN NEW; END IF;
INSERT INTO message_stats(to_login,to_block_number,to_block_hash,replies_count)
VALUES(NEW.to_login,NEW.to_block_number,NEW.to_block_hash,1)
VALUES(lower(NEW.to_login),NEW.to_block_number,NEW.to_block_hash,1)
ON CONFLICT(to_login,to_block_number,to_block_hash) DO UPDATE SET replies_count=message_stats.replies_count+1;
RETURN NEW;
END $$;
@@ -30,6 +30,7 @@ dependencies {
implementation project(':shine-server-crypto') // модуль сервера для работы с криптографией
implementation project(':shine-server-blockchain') // модуль для работы с блокчейном
implementation project(':shine-server-solana-users-sync') // Нормализованный адрес PDA
implementation project(':shine-server-db') // модуль для работы с БД содержит и сущности из БД и саму работу с БД
implementation project(':shine-server-geo') // модуль для определения геолокации по IP
@@ -169,6 +169,8 @@ import server.logic.ws_protocol.JSON.handlers.system.entyties.Net_ListBlockchain
import server.logic.ws_protocol.JSON.handlers.system.entyties.Net_Ping_Request;
import server.logic.ws_protocol.JSON.handlers.system.entyties.Net_ServerHello_Request;
import server.logic.ws_protocol.JSON.handlers.registration.Net_Registration_Handler;
import server.logic.ws_protocol.JSON.handlers.registration.Net_Registration_Request;
import java.util.Map;
/**
@@ -186,6 +188,14 @@ public final class JsonHandlerRegistry {
Map.entry("SearchUsers", new Net_SearchUsers_Handler()),
Map.entry("SearchChannels", new Net_SearchChannels_Handler()),
// --- Registration V2: 6 согласованных публичных операций ---
Map.entry("GetNamespaces", new Net_Registration_Handler("GetNamespaces")),
Map.entry("CheckRegistrationLogin", new Net_Registration_Handler("CheckRegistrationLogin")),
Map.entry("CheckRegistrationEmail", new Net_Registration_Handler("CheckRegistrationEmail")),
Map.entry("StartFreeRegistration", new Net_Registration_Handler("StartFreeRegistration")),
Map.entry("ConfirmFreeRegistration", new Net_Registration_Handler("ConfirmFreeRegistration")),
Map.entry("GetRegistrationStatus", new Net_Registration_Handler("GetRegistrationStatus")),
// --- auth ---
Map.entry("ResolveLoginForAuth", new Net_ResolveLoginForAuth_Handler()),
Map.entry("AuthChallenge", new Net_AuthChallenge_Handler()),
@@ -291,6 +301,14 @@ public final class JsonHandlerRegistry {
Map.entry("SearchUsers", Net_SearchUsers_Request.class),
Map.entry("SearchChannels", Net_SearchChannels_Request.class),
// --- Registration V2 ---
Map.entry("GetNamespaces", Net_Registration_Request.class),
Map.entry("CheckRegistrationLogin", Net_Registration_Request.class),
Map.entry("CheckRegistrationEmail", Net_Registration_Request.class),
Map.entry("StartFreeRegistration", Net_Registration_Request.class),
Map.entry("ConfirmFreeRegistration", Net_Registration_Request.class),
Map.entry("GetRegistrationStatus", Net_Registration_Request.class),
// --- auth ---
Map.entry("ResolveLoginForAuth", Net_ResolveLoginForAuth_Request.class),
Map.entry("AuthChallenge", Net_AuthChallenge_Request.class),
@@ -76,9 +76,12 @@ public final class JsonInboundProcessor {
return out;
}
// DEBUG: сырой вход (обрезаем, чтобы не убить лог)
// Не писать email, challenge и ключи в лог даже на DEBUG.
if (log.isDebugEnabled()) {
log.debug("JSON IN (login={}, sessionId={}): {}", ctxLogin, ctxSessionId, shorten(json, 1200));
log.debug("JSON IN (login={}, sessionId={}): {}", ctxLogin, ctxSessionId,
json.contains("FreeRegistration") || json.contains("RegistrationEmail")
|| json.contains("RegistrationLogin") || json.contains("GetNamespaces")
|| json.contains("GetRegistrationStatus") ? "<registration payload redacted>" : shorten(json, 1200));
}
// 1) Парсим общий пакет
@@ -178,7 +181,7 @@ public final class JsonInboundProcessor {
} catch (Exception mapErr) {
// Важно: вот это часто “теряется”, если не логировать отдельно
log.error("❌ JSON map error (op={}, requestId={}, login={}, sessionId={}): merged={}",
op, safe(requestId), ctxLogin, ctxSessionId, shorten(merged.toString(), 1200), mapErr);
op, safe(requestId), ctxLogin, ctxSessionId, "<redacted>", mapErr);
Net_Exception_Response err = NetExceptionResponseFactory.error(
op,
@@ -202,7 +205,7 @@ public final class JsonInboundProcessor {
// DEBUG: нормализованный запрос (уже распарсен)
if (log.isDebugEnabled()) {
log.debug("REQ OBJ (login={}, sessionId={}, op={}, requestId={}): {}",
ctxLogin, ctxSessionId, safe(op), safe(requestId), shorten(safeToString(request), 1200));
ctxLogin, ctxSessionId, safe(op), safe(requestId), isRegistrationOperation(op) ? "<registration payload redacted>" : shorten(safeToString(request), 1200));
}
// REMOTE-пользователь успешно авторизован, но этот сервер не является
@@ -372,6 +375,11 @@ public final class JsonInboundProcessor {
}
}
private static boolean isRegistrationOperation(String op) {
return op != null && (op.endsWith("Registration") || op.startsWith("CheckRegistration")
|| op.equals("GetNamespaces") || op.equals("GetRegistrationStatus"));
}
private static String safe(String s) {
return s != null ? s : "";
}
@@ -5,6 +5,7 @@ import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import utils.config.SolanaProgramsConfig;
import shine.db.dao.RegistrationIdentityDAO;
import java.net.URI;
import java.net.http.HttpClient;
@@ -34,6 +35,10 @@ public final class SolanaUserPdaImportService {
public static SessionTypeCheckResult checkSessionTypeAgainstPda(String loginRaw, String sessionKeyApi, int requestedSessionType) throws Exception {
String login = normalizeLogin(loginRaw);
if (login == null) return SessionTypeCheckResult.noRecord();
// У FREE_CERT нет Solana PDA. Это НЕ означает отсутствие идентичности:
// AuthChallenge и подпись clientKey уже проверяются через общий индекс.
RegistrationIdentityDAO.ResolvedIdentity identity = RegistrationIdentityDAO.getInstance().get(login);
if (identity != null && identity.isFree()) return SessionTypeCheckResult.noRecord();
ParsedSolanaUser parsed = fetchFromSolana(login);
if (parsed == null) return SessionTypeCheckResult.noRecord();
@@ -103,54 +108,34 @@ public final class SolanaUserPdaImportService {
}
private static byte[] fetchRawUserPda(String login) throws Exception {
String loginB58 = toBase58(login.getBytes(StandardCharsets.UTF_8));
String lenB58 = toBase58(new byte[]{(byte) login.length()});
String reqJson = """
{
"jsonrpc":"2.0",
"id":1,
"method":"getProgramAccounts",
"params":[
"%s",
{
"encoding":"base64",
"filters":[
{"memcmp":{"offset":61,"bytes":"%s"}},
{"memcmp":{"offset":62,"bytes":"%s"}}
]
}
]
}
""".formatted(SolanaProgramsConfig.SHINE_USERS_PROGRAM_ID, lenB58, loginB58);
// Запись хранит исходный регистр, но адрес PDA зависит только от lowercase.
String address = sync.util.SolanaPdaUtil.findUserPdaV2(login, SolanaProgramsConfig.SHINE_USERS_PROGRAM_ID);
String reqJson = MAPPER.writeValueAsString(Map.of(
"jsonrpc", "2.0", "id", 1,
"method", "getAccountInfo",
"params", List.of(address, Map.of("encoding", "base64", "commitment", "confirmed"))));
HttpRequest req = HttpRequest.newBuilder()
.uri(URI.create(SolanaProgramsConfig.SOLANA_RPC_URL))
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(reqJson))
.build();
HttpResponse<String> resp = HTTP.send(req, HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
if (resp.statusCode() < 200 || resp.statusCode() >= 300) {
throw new IllegalStateException("Solana RPC HTTP status=" + resp.statusCode());
}
JsonNode root = MAPPER.readTree(resp.body());
if (root.hasNonNull("error")) {
throw new IllegalStateException("Solana RPC error: " + root.get("error").toString());
throw new IllegalStateException("Solana RPC error: " + root.get("error"));
}
JsonNode result = root.path("result");
if (!result.isArray() || result.isEmpty()) return null;
for (JsonNode item : result) {
JsonNode dataNode = item.path("account").path("data");
if (!dataNode.isArray() || dataNode.size() < 1) continue;
String b64 = dataNode.get(0).asText("");
if (b64.isBlank()) continue;
return Base64.getDecoder().decode(b64);
JsonNode account = root.path("result").path("value");
if (account.isMissingNode() || account.isNull()) return null;
if (!SolanaProgramsConfig.SHINE_USERS_PROGRAM_ID.equals(account.path("owner").asText())) {
throw new IllegalStateException("PDA принадлежит другой программе");
}
return null;
JsonNode data = account.path("data");
if (!data.isArray() || data.isEmpty()) return null;
String b64 = data.get(0).asText("");
return b64.isBlank() ? null : Base64.getDecoder().decode(b64);
}
private static ParsedSolanaUser parseUserPda(byte[] raw) {
@@ -253,7 +238,7 @@ public final class SolanaUserPdaImportService {
}
if (blockchainKey32 == null || clientKey32 == null || forkCount <= 0 || forkCount > 999) return null;
String blockchainName = login + "-" + String.format(Locale.ROOT, "%03d", forkCount);
String blockchainName = normalizeLogin(login) + "-" + String.format(Locale.ROOT, "%03d", forkCount);
return new ParsedSolanaUser(
login,
blockchainName,
@@ -360,7 +345,7 @@ public final class SolanaUserPdaImportService {
return out;
}
// Нужен для memcmp.bytes в Solana RPC.
// Вспомогательная base58-конверсия для других совместимых полей.
private static String toBase58(byte[] input) {
final char[] alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz".toCharArray();
int zeros = 0;
@@ -37,11 +37,13 @@ import shine.db.dao.BlockchainStateDAO;
import shine.db.dao.BlocksDAO;
import shine.db.dao.CanonicalChainResolver;
import shine.db.dao.ChannelNameStateDAO;
import shine.db.dao.CurrentUsersDAO;
import shine.db.dao.UserNotificationsStateDAO;
import shine.db.dao.UserParamsDAO;
import shine.db.entities.BlockchainStateEntry;
import shine.db.entities.BlockEntry;
import shine.db.entities.ChannelNameStateEntry;
import shine.db.entities.CurrentUserEntry;
import shine.db.entities.UserNotificationEntry;
import shine.db.entities.UserParamEntry;
import utils.blockchain.BlockchainNameUtil;
@@ -68,6 +70,7 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
private final BlocksDAO blocksDAO = BlocksDAO.getInstance();
private final CanonicalChainResolver canonicalChain = CanonicalChainResolver.getInstance();
private final BlockchainStateDAO stateDAO = BlockchainStateDAO.getInstance();
private final CurrentUsersDAO currentUsersDAO = CurrentUsersDAO.getInstance();
private final UserParamsDAO userParamsDAO = UserParamsDAO.getInstance();
private final ChannelNameStateDAO channelNameStateDAO = ChannelNameStateDAO.getInstance();
@@ -202,6 +205,8 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
case "bad_type_tag" -> "Некорректный индексный t-тег ANS-104";
case "bad_channel_tag" -> "Некорректный тег канала ANS-104";
case "bad_block_body" -> "Некорректное тело блока";
case "header_login_mismatch" -> "HEADER должен содержать имя точно в регистре регистрации";
case "header_identity_lookup_failed" -> "Не удалось проверить регистрационное имя HEADER";
case "bad_channel_name" -> "Некорректное название канала";
case "bad_block_number" -> "Некорректный номер блока";
case "req_global_mismatch" -> "Номер блока в запросе не совпадает с номером в блоке";
@@ -255,7 +260,7 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
}
// 1) state обязателен
final BlockchainStateEntry st;
BlockchainStateEntry st;
try {
st = stateDAO.getByBlockchainName(blockchainName);
} catch (Exception e) {
@@ -264,6 +269,37 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
return new AddBlockResult(WireCodes.Status.INTERNAL_ERROR, "db_error", 0, "");
}
if (st == null) {
// Runtime-проекция могла отсутствовать у пользователей, зарегистрированных
// ранней версией free-регистрации. Восстанавливаем только для точно
// существующего владельца этой цепочки; сам блок всё равно проходит
// полную проверку ключа и подписи ниже.
try {
CurrentUserEntry user = currentUsersDAO.getByBlockchainName(blockchainName);
if (user != null) {
BlockchainStateEntry recovered = new BlockchainStateEntry();
recovered.setBlockchainName(user.getBlockchainName());
recovered.setLogin(user.getLogin());
recovered.setBlockchainKey(user.getBlockchainKey());
recovered.setSizeLimit(100_000L);
recovered.setFileSizeBytes(0L);
recovered.setLastBlockNumber(-1);
recovered.setLastBlockHash(new byte[32]);
recovered.setUpdatedAtMs(System.currentTimeMillis());
stateDAO.insertIfMissing(recovered);
st = stateDAO.getByBlockchainName(blockchainName);
if (st != null) {
log.warn("AddBlock: восстановлена отсутствующая blockchain_state для login={}, blockchainName={}",
user.getLogin(), blockchainName);
}
}
} catch (Exception e) {
log.error("AddBlock: не удалось восстановить blockchain_state (login={}, blockchainName={})",
login, blockchainName, e);
return new AddBlockResult(WireCodes.Status.INTERNAL_ERROR, "db_error", 0, "");
}
}
if (st == null) {
log.warn("AddBlock: blockchain_state_not_found (login={}, blockchainName={}, reqGlobalNumber={})",
login, blockchainName, globalNumberFromReq);
@@ -351,8 +387,17 @@ public final class Net_AddBlock_Handler implements JsonMessageHandler {
if (!(block.body instanceof HeaderBody headerBody)) {
return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "header_required_as_block_zero", serverLastNum, serverLastHashHex);
}
if (!login.equals(headerBody.login)) {
return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "header_login_mismatch", serverLastNum, serverLastHashHex);
// HEADER фиксирует написание из регистрационной записи, а не lower-case имя цепочки.
// Проверка точная: другой регистр не может создать альтернативное "официальное" имя.
try {
CurrentUserEntry registeredOwner = currentUsersDAO.getByLogin(login);
if (registeredOwner == null || !headerBody.login.equals(registeredOwner.getLogin())
|| !login.equalsIgnoreCase(registeredOwner.getLogin())) {
return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "header_login_mismatch", serverLastNum, serverLastHashHex);
}
} catch (Exception e) {
log.error("AddBlock: cannot verify registered HEADER login for {}", blockchainName, e);
return new AddBlockResult(WireCodes.Status.INTERNAL_ERROR, "header_identity_lookup_failed", serverLastNum, serverLastHashHex);
}
} else if (block.body instanceof HeaderBody) {
return new AddBlockResult(WireCodes.Status.BAD_REQUEST, "header_must_be_block_zero", serverLastNum, serverLastHashHex);
@@ -13,10 +13,10 @@ import server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory;
import server.logic.ws_protocol.WireCodes;
import shine.db.dao.BlockchainStateDAO;
import shine.db.dao.CanonicalChainResolver;
import shine.db.dao.SolanaUserPdaCurrentDAO;
import shine.db.dao.CurrentUsersDAO;
import shine.db.entities.BlockEntry;
import shine.db.entities.BlockchainStateEntry;
import shine.db.entities.SolanaUserPdaCurrentEntry;
import shine.db.entities.CurrentUserEntry;
import java.util.ArrayList;
import java.util.Collections;
@@ -26,7 +26,7 @@ import java.util.List;
public final class Net_GetMyBlockchain_Handler implements JsonMessageHandler {
private final CanonicalChainResolver canonical = CanonicalChainResolver.getInstance();
private final BlockchainStateDAO states = BlockchainStateDAO.getInstance();
private final SolanaUserPdaCurrentDAO users = SolanaUserPdaCurrentDAO.getInstance();
private final CurrentUsersDAO users = CurrentUsersDAO.getInstance();
@Override
public Net_Response handle(Net_Request baseReq, ConnectionContext ctx) {
@@ -36,7 +36,7 @@ public final class Net_GetMyBlockchain_Handler implements JsonMessageHandler {
}
try {
String login = ctx.getLogin().trim();
SolanaUserPdaCurrentEntry user = users.getByLogin(login);
CurrentUserEntry user = users.getByLogin(login);
if (user == null || user.getBlockchainName() == null || user.getBlockchainName().isBlank()) {
return NetExceptionResponseFactory.error(req, 404, "BLOCKCHAIN_NOT_FOUND", "Текущий блокчейн пользователя не найден");
}
@@ -16,6 +16,8 @@ import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Locale;
final class ChannelsReadSupport {
static final int MSG_TYPE_TEXT = 1;
@@ -39,6 +41,19 @@ final class ChannelsReadSupport {
}
}
// Пользовательское отображение — из реестра, не из normalized blocks.login.
// Кэш ограничен временем одного ответа и не требует дополнительных запросов на каждый пост.
static String officialLogin(Connection c, Map<String, String> cache, String raw) throws SQLException {
if (raw == null || raw.isBlank()) return raw;
String key = raw.trim().toLowerCase(Locale.ROOT);
String value = cache.get(key);
if (value != null) return value;
value = canonicalLogin(c, raw);
if (value == null || value.isBlank()) value = raw;
cache.put(key, value);
return value;
}
static ChannelMeta detectChannelMeta(Connection c, String ownerBch, int rootNumber) throws SQLException {
ChannelMeta meta = new ChannelMeta();
meta.channelTypeVersion = CreateChannelBody.CHANNEL_TYPE_VERSION_DEFAULT & 0xFFFF;
@@ -20,6 +20,8 @@ import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
public class Net_GetChannelMessages_Handler implements JsonMessageHandler {
private static final Logger log = LoggerFactory.getLogger(Net_GetChannelMessages_Handler.class);
@@ -44,6 +46,7 @@ public class Net_GetChannelMessages_Handler implements JsonMessageHandler {
boolean asc = req.getSort() == null || !"desc".equalsIgnoreCase(req.getSort());
try (Connection c = DbController.getInstance().getConnection()) {
Map<String, String> officialLogins = new HashMap<>();
String viewerLogin = ctx != null ? ctx.getLogin() : null;
if (viewerLogin == null || viewerLogin.isBlank()) {
viewerLogin = ChannelsReadSupport.canonicalLogin(c, req.getLogin());
@@ -58,7 +61,7 @@ public class Net_GetChannelMessages_Handler implements JsonMessageHandler {
Net_GetChannelMessages_Response.Channel channel = new Net_GetChannelMessages_Response.Channel();
channel.setOwnerBlockchainName(ownerBch);
channel.setOwnerLogin(BlockchainNameUtil.loginFromBlockchainName(ownerBch));
channel.setOwnerLogin(ChannelsReadSupport.officialLogin(c, officialLogins, BlockchainNameUtil.loginFromBlockchainName(ownerBch)));
ChannelsReadSupport.ChannelMeta meta = ChannelsReadSupport.detectChannelMeta(c, ownerBch, lineCode);
channel.setChannelName(meta.channelName);
channel.setDisplayName(meta.displayName == null || meta.displayName.isBlank() ? meta.channelName : meta.displayName);
@@ -88,7 +91,7 @@ public class Net_GetChannelMessages_Handler implements JsonMessageHandler {
eventRef.setBlockNumber(event.blockNumber);
eventRef.setBlockHash(ChannelsReadSupport.toHex(event.blockHash));
outEvent.setMessageRef(eventRef);
outEvent.setAuthorLogin(event.login);
outEvent.setAuthorLogin(ChannelsReadSupport.officialLogin(c, officialLogins, event.login));
outEvent.setAuthorBlockchainName(event.bchName);
outEvent.setLineStep(event.lineStep);
outEvent.setCreatedAtMs(event.createdAtMs);
@@ -133,7 +136,7 @@ public class Net_GetChannelMessages_Handler implements JsonMessageHandler {
msgRef.setBlockHash(ChannelsReadSupport.toHex(post.blockHash));
item.setMessageRef(msgRef);
item.setMsgSubType(post.msgSubType);
item.setAuthorLogin(post.login);
item.setAuthorLogin(ChannelsReadSupport.officialLogin(c, officialLogins, post.login));
item.setAuthorBlockchainName(post.bchName);
item.setLineStep(post.thisLineNumber);
item.setTargetBlockchainName(post.toBchName);
@@ -21,6 +21,8 @@ import java.util.Comparator;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
public class Net_GetMessageThread_Handler implements JsonMessageHandler {
private static final Logger log = LoggerFactory.getLogger(Net_GetMessageThread_Handler.class);
@@ -37,6 +39,7 @@ public class Net_GetMessageThread_Handler implements JsonMessageHandler {
int childLimit = req.getLimitChildrenPerNode() == null ? 50 : Math.max(1, req.getLimitChildrenPerNode());
try (Connection c = DbController.getInstance().getConnection()) {
Map<String, String> officialLogins = new HashMap<>();
String viewerLogin = ctx != null ? ctx.getLogin() : null;
if (viewerLogin == null || viewerLogin.isBlank()) {
viewerLogin = ChannelsReadSupport.canonicalLogin(c, req.getLogin());
@@ -51,7 +54,7 @@ public class Net_GetMessageThread_Handler implements JsonMessageHandler {
resp.setRequestId(req.getRequestId());
resp.setStatus(WireCodes.Status.OK);
resp.setFocus(toNode(c, focusRow, viewerLogin));
resp.setFocus(toNode(c, focusRow, viewerLogin, officialLogins));
List<Net_GetMessageThread_Response.MessageNode> ancestors = new ArrayList<>();
PostRow cur = focusRow;
@@ -68,12 +71,12 @@ public class Net_GetMessageThread_Handler implements JsonMessageHandler {
parent = findByNumber(c, cur.toBchName, cur.toBlockNumber);
}
if (parent == null) break;
ancestors.add(0, toNode(c, parent, viewerLogin));
ancestors.add(0, toNode(c, parent, viewerLogin, officialLogins));
cur = parent;
}
resp.setAncestors(ancestors);
resp.setDescendants(loadChildren(c, focusRow, depthDown, childLimit, viewerLogin));
resp.setDescendants(loadChildren(c, focusRow, depthDown, childLimit, viewerLogin, officialLogins));
return resp;
} catch (Exception e) {
log.error("GetMessageThread failed", e);
@@ -97,14 +100,14 @@ public class Net_GetMessageThread_Handler implements JsonMessageHandler {
return null;
}
private List<Net_GetMessageThread_Response.MessageNodeTree> loadChildren(Connection c, PostRow parent, int depthDown, int childLimit, String viewerLogin) throws Exception {
private List<Net_GetMessageThread_Response.MessageNodeTree> loadChildren(Connection c, PostRow parent, int depthDown, int childLimit, String viewerLogin, Map<String, String> officialLogins) throws Exception {
if (depthDown <= 0) return List.of();
List<PostRow> replies = findRepliesAndRatings(c, parent.bchName, parent.blockNumber, parent.blockHash, childLimit);
List<Net_GetMessageThread_Response.MessageNodeTree> out = new ArrayList<>();
for (PostRow row : replies) {
Net_GetMessageThread_Response.MessageNodeTree t = new Net_GetMessageThread_Response.MessageNodeTree();
t.setNode(toNode(c, row, viewerLogin));
t.setChildren(loadChildren(c, row, depthDown - 1, childLimit, viewerLogin));
t.setNode(toNode(c, row, viewerLogin, officialLogins));
t.setChildren(loadChildren(c, row, depthDown - 1, childLimit, viewerLogin, officialLogins));
out.add(t);
}
return out;
@@ -233,14 +236,14 @@ public class Net_GetMessageThread_Handler implements JsonMessageHandler {
return row;
}
private Net_GetMessageThread_Response.MessageNode toNode(Connection c, PostRow row, String viewerLogin) throws Exception {
private Net_GetMessageThread_Response.MessageNode toNode(Connection c, PostRow row, String viewerLogin, Map<String, String> officialLogins) throws Exception {
Net_GetMessageThread_Response.MessageNode node = new Net_GetMessageThread_Response.MessageNode();
Net_GetChannelMessages_Response.BlockRef ref = new Net_GetChannelMessages_Response.BlockRef();
ref.setBlockNumber(row.blockNumber);
ref.setBlockHash(ChannelsReadSupport.toHex(row.blockHash));
node.setMessageRef(ref);
node.setMsgSubType(row.msgSubType);
node.setAuthorLogin(row.login);
node.setAuthorLogin(ChannelsReadSupport.officialLogin(c, officialLogins, row.login));
node.setAuthorBlockchainName(row.bchName);
node.setLineStep(row.thisLineNumber);
node.setTargetBlockchainName(row.toBchName);
@@ -19,6 +19,8 @@ import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import java.util.HashMap;
import java.util.Map;
public class Net_ListSubscriptionsFeed_Handler implements JsonMessageHandler {
private static final Logger log = LoggerFactory.getLogger(Net_ListSubscriptionsFeed_Handler.class);
@@ -59,11 +61,12 @@ public class Net_ListSubscriptionsFeed_Handler implements JsonMessageHandler {
private List<Net_ListSubscriptionsFeed_Response.ChannelSummary> buildSummaries(Connection c, String viewerLogin, List<ChannelKey> keys) throws Exception {
List<Net_ListSubscriptionsFeed_Response.ChannelSummary> out = new ArrayList<>();
Map<String, String> officialLogins = new HashMap<>();
for (ChannelKey key : keys) {
Net_ListSubscriptionsFeed_Response.ChannelSummary row = new Net_ListSubscriptionsFeed_Response.ChannelSummary();
Net_ListSubscriptionsFeed_Response.ChannelRef channelRef = new Net_ListSubscriptionsFeed_Response.ChannelRef();
ChannelsReadSupport.ChannelMeta meta = ChannelsReadSupport.detectChannelMeta(c, key.ownerBch, key.rootNumber);
channelRef.setOwnerLogin(key.ownerLogin);
channelRef.setOwnerLogin(ChannelsReadSupport.officialLogin(c, officialLogins, key.ownerLogin));
channelRef.setOwnerBlockchainName(key.ownerBch);
channelRef.setChannelName(meta.channelName);
channelRef.setDisplayName(meta.displayName == null || meta.displayName.isBlank() ? meta.channelName : meta.displayName);
@@ -108,7 +111,7 @@ public class Net_ListSubscriptionsFeed_Handler implements JsonMessageHandler {
lm.setMessageRef(msgRef);
lm.setText(textInfo.text);
lm.setCreatedAtMs(textInfo.createdAtMs);
lm.setAuthorLogin(actual.login);
lm.setAuthorLogin(ChannelsReadSupport.officialLogin(c, officialLogins, actual.login));
lm.setAuthorBlockchainName(actual.bchName);
row.setLastMessage(lm);
}
@@ -11,6 +11,23 @@ import java.util.Base64;
final class KeyRotationApiSupport {
private KeyRotationApiSupport() {}
/** Free identity не имеет Solana PDA и не вправе менять ключи/форки. */
static server.logic.ws_protocol.JSON.entyties.Net_Response denyFreeRotation(
server.logic.ws_protocol.JSON.entyties.Net_Request req, String login) {
try {
var identity = shine.db.dao.RegistrationIdentityDAO.getInstance().get(login);
if (identity == null) return server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory.error(
req, 404, "KEY_ROTATION_USER_NOT_FOUND", "Пользователь не найден");
if (identity.isFree()) return server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory.error(
req, 403, "KEY_ROTATION_PAID_ONLY", "Для смены ключей необходима регистрация в Solana");
return null;
} catch (java.sql.SQLException e) {
// fail closed при неготовой миграции / ошибке БД
return server.logic.ws_protocol.JSON.utils.NetExceptionResponseFactory.error(
req, 503, "KEY_ROTATION_IDENTITY_UNAVAILABLE", "Невозможно проверить полномочия пользователя");
}
}
static String normalizePublicKey32(String raw) {
String normalized = KeyEncodingUtil.normalizeKeyToBase64_32(raw);
if (normalized == null || normalized.isBlank()) {
@@ -20,6 +20,8 @@ public final class Net_KeyRotationAbort_Handler implements JsonMessageHandler {
if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) {
return NetExceptionResponseFactory.error(req, 401, "AUTH_REQUIRED", "Нужна авторизованная пользовательская сессия");
}
var freeCheck = KeyRotationApiSupport.denyFreeRotation(req, ctx.getLogin());
if (freeCheck != null) return freeCheck;
try {
KeyRotationSessionEntry current = rotations.getActiveByLogin(ctx.getLogin().trim());
if (current == null) return KeyRotationApiSupport.response(req.getOp(), req.getRequestId(), null);
@@ -44,6 +44,8 @@ public final class Net_KeyRotationAddBlock_Handler implements JsonMessageHandler
if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) {
return NetExceptionResponseFactory.error(req, 401, "AUTH_REQUIRED", "Нужна авторизованная пользовательская сессия");
}
var freeCheck = KeyRotationApiSupport.denyFreeRotation(req, ctx.getLogin());
if (freeCheck != null) return freeCheck;
if (req.getBlockNumber() < 0 || req.getBlockBytesB64() == null || req.getBlockBytesB64().isBlank()) {
return NetExceptionResponseFactory.error(req, 400, "KEY_ROTATION_BAD_BLOCK", "blockNumber и blockBytesB64 обязательны");
}
@@ -22,6 +22,8 @@ public final class Net_KeyRotationContinue_Handler implements JsonMessageHandler
if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) {
return NetExceptionResponseFactory.error(req, 401, "AUTH_REQUIRED", "Нужна авторизованная пользовательская сессия");
}
var freeCheck = KeyRotationApiSupport.denyFreeRotation(req, ctx.getLogin());
if (freeCheck != null) return freeCheck;
try {
String login = ctx.getLogin().trim();
KeyRotationSessionEntry current = rotations.getActiveByLogin(login);
@@ -47,6 +47,8 @@ public final class Net_KeyRotationFinishChain_Handler implements JsonMessageHand
if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) {
return NetExceptionResponseFactory.error(req, 401, "AUTH_REQUIRED", "Нужна авторизованная пользовательская сессия");
}
var freeCheck = KeyRotationApiSupport.denyFreeRotation(req, ctx.getLogin());
if (freeCheck != null) return freeCheck;
String login = ctx.getLogin().trim();
KeyRotationSessionEntry initial;
@@ -24,6 +24,8 @@ public final class Net_KeyRotationRotatePda_Handler implements JsonMessageHandle
if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) {
return NetExceptionResponseFactory.error(req, 401, "AUTH_REQUIRED", "Нужна авторизованная пользовательская сессия");
}
var freeCheck = KeyRotationApiSupport.denyFreeRotation(req, ctx.getLogin());
if (freeCheck != null) return freeCheck;
String login = ctx.getLogin().trim();
final String signature;
@@ -39,7 +41,18 @@ public final class Net_KeyRotationRotatePda_Handler implements JsonMessageHandle
return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_NOT_ACTIVE", "Активная ротация отсутствует");
}
if (current.getStatus() == KeyRotationStatus.PDA_ROTATED) {
// Solana sync и rebuild работают независимо от уведомления клиента.
// При повторе после подтверждённой PDA возвращаем реальный этап, а не 409.
if (current.getStatus() == KeyRotationStatus.PDA_ROTATED
|| current.getStatus() == KeyRotationStatus.REBUILDING_SERVER
|| current.getStatus() == KeyRotationStatus.WALLET_MIGRATION
|| current.getStatus() == KeyRotationStatus.MESSAGE_MIGRATION
|| current.getStatus() == KeyRotationStatus.FINALIZING) {
String stored = current.getPdaRotationSignature();
if (stored != null && !stored.isBlank() && !stored.equals(signature)) {
return NetExceptionResponseFactory.error(req, 409, "KEY_ROTATION_PDA_SIGNATURE_CONFLICT",
"Для этой ротации уже сохранена другая Solana transaction signature");
}
var fresh = CurrentUsersDAO.getInstance().getByLogin(login);
if (fresh != null) ctx.setCurrentUser(fresh);
return KeyRotationApiSupport.response(req.getOp(), req.getRequestId(), current);
@@ -39,6 +39,8 @@ public final class Net_KeyRotationStart_Handler implements JsonMessageHandler {
if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) {
return NetExceptionResponseFactory.error(req, 401, "AUTH_REQUIRED", "Нужна авторизованная пользовательская сессия");
}
var freeCheck = KeyRotationApiSupport.denyFreeRotation(req, ctx.getLogin());
if (freeCheck != null) return freeCheck;
String login = ctx.getLogin().trim();
String currentSessionId = ctx.getSessionId() == null ? "" : ctx.getSessionId().trim();
if (currentSessionId.isEmpty()) {
@@ -20,6 +20,8 @@ public final class Net_KeyRotationStatus_Handler implements JsonMessageHandler {
if (ctx == null || !ctx.isAuthenticatedUser() || ctx.getLogin() == null || ctx.getLogin().isBlank()) {
return NetExceptionResponseFactory.error(req, 401, "AUTH_REQUIRED", "Нужна авторизованная пользовательская сессия");
}
var freeCheck = KeyRotationApiSupport.denyFreeRotation(req, ctx.getLogin());
if (freeCheck != null) return freeCheck;
try {
String login = ctx.getLogin().trim();
KeyRotationSessionEntry current = rotations.getActiveByLogin(login);
@@ -0,0 +1,47 @@
package server.logic.ws_protocol.JSON.handlers.registration;
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.utils.NetExceptionResponseFactory;
import server.logic.ws_protocol.WireCodes;
/** API доступно анонимному клиенту, но без разрешения приватных операций. */
public final class Net_Registration_Handler implements JsonMessageHandler {
private final String operation;
private static final java.util.Map<ConnectionContext, long[]> LIMITS =
java.util.Collections.synchronizedMap(new java.util.WeakHashMap<>());
private static long globalMinute=-1;
private static int globalHits=0;
private static boolean throttled(ConnectionContext ctx) {
long minute=System.currentTimeMillis()/60000L;
synchronized (LIMITS) {
if(globalMinute!=minute){globalMinute=minute;globalHits=0;}
if(++globalHits>1200) return true;
if(ctx==null) return false;
long[] bucket=LIMITS.computeIfAbsent(ctx, c->new long[]{minute,0});
if(bucket[0]!=minute){bucket[0]=minute;bucket[1]=0;}
return ++bucket[1]>30;
}
}
public Net_Registration_Handler(String operation) { this.operation=operation; }
@Override public Net_Response handle(Net_Request base, ConnectionContext ctx) throws Exception {
Net_Registration_Request request=(Net_Registration_Request)base;
if (throttled(ctx)) return NetExceptionResponseFactory.error(request,429,"RATE_LIMITED","Слишком много запросов регистрации");
RegistrationApiBridge.Service service=RegistrationApiBridge.get();
if (service==null) return NetExceptionResponseFactory.error(request,503,"REGISTRATION_UNAVAILABLE","Регистрация на сервере пока не настроена");
try {
java.util.Map<String,Object> values=service.execute(operation,request);
Net_Registration_Response out=new Net_Registration_Response();
out.setOp(request.getOp()); out.setRequestId(request.getRequestId());
out.setStatus(WireCodes.Status.OK); out.setValues(values);
return out;
} catch (IllegalArgumentException e) {
// Без echo исходного email, чтобы не публиковать PII в ответе/логе.
return NetExceptionResponseFactory.error(request,400,"INVALID_REGISTRATION_INPUT","Данные регистрации не прошли проверку");
} catch (IllegalStateException e) {
return NetExceptionResponseFactory.error(request,409,"REGISTRATION_CONFLICT","Регистрация недоступна или данные уже заняты");
}
}
}
@@ -0,0 +1,28 @@
package server.logic.ws_protocol.JSON.handlers.registration;
import server.logic.ws_protocol.JSON.entyties.Net_Request;
/** JSON payload; публичные данные пользователя, пароли/приватные ключи не принимаются. */
public final class Net_Registration_Request extends Net_Request {
private String fullLogin;
private String email;
private String rootPublicKeyB64;
private String blockchainPublicKeyB64;
private String clientPublicKeyB64;
private String challengeId;
private String code;
public String getFullLogin() { return fullLogin; }
public void setFullLogin(String v) { fullLogin = v; }
public String getEmail() { return email; }
public void setEmail(String v) { email = v; }
public String getRootPublicKeyB64() { return rootPublicKeyB64; }
public void setRootPublicKeyB64(String v) { rootPublicKeyB64 = v; }
public String getBlockchainPublicKeyB64() { return blockchainPublicKeyB64; }
public void setBlockchainPublicKeyB64(String v) { blockchainPublicKeyB64 = v; }
public String getClientPublicKeyB64() { return clientPublicKeyB64; }
public void setClientPublicKeyB64(String v) { clientPublicKeyB64 = v; }
public String getChallengeId() { return challengeId; }
public void setChallengeId(String v) { challengeId = v; }
public String getCode() { return code; }
public void setCode(String v) { code = v; }
}
@@ -0,0 +1,12 @@
package server.logic.ws_protocol.JSON.handlers.registration;
import server.logic.ws_protocol.JSON.entyties.Net_Response;
import java.util.Map;
import com.fasterxml.jackson.annotation.JsonAnyGetter;
/** Значения результата помещаются на верхний уровень объекта перед стандартной WS-обёрткой. */
public final class Net_Registration_Response extends Net_Response {
private Map<String, Object> values = Map.of();
public void setValues(Map<String,Object> values) { this.values = Map.copyOf(values); }
@JsonAnyGetter public Map<String,Object> getValues() { return values; }
}
@@ -0,0 +1,15 @@
package server.logic.ws_protocol.JSON.handlers.registration;
import java.util.Map;
/** SPI: HTTP/WS модуль не зависит от archive-модуля, устраняя циклический Gradle dependency. */
public final class RegistrationApiBridge {
@FunctionalInterface public interface Service {
Map<String, Object> execute(String operation, Net_Registration_Request request) throws Exception;
}
private static volatile Service service;
private RegistrationApiBridge() {}
public static void install(Service implementation) { service = java.util.Objects.requireNonNull(implementation); }
public static void uninstall() { service = null; }
public static Service get() { return service; }
}
@@ -2,6 +2,7 @@ package sync.codec;
import com.fasterxml.jackson.databind.JsonNode;
import sync.util.Base58Util;
import sync.util.SolanaPdaUtil;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
@@ -29,6 +30,8 @@ public final class ShineUsersCodec {
public static final int IX_CLOSE_LEGACY_USER_PDA =
6;
public static final int IX_CREATE_NAMESPACE = 7;
public static final long START_REGISTRATION_FEE_LAMPORTS =
10_000_000L;
@@ -151,6 +154,16 @@ public final class ShineUsersCodec {
null
);
case IX_CREATE_NAMESPACE ->
new ParsedInstruction(
TxKind.CREATE_NAMESPACE,
true,
accountAt(accounts, 1),
null,
null,
null
);
case IX_CREATE_USER_PDA ->
parseV12PdaMutationInstruction(
TxKind.CREATE_USER_PDA, reader, accounts
@@ -731,10 +744,55 @@ public final class ShineUsersCodec {
}
}
/** Строгий декодер бинарного namespace 1.0 с on-chain PDA address check. */
public static NamespaceSnapshot parseNamespaceAccount(
String pdaAddress, long slot, String rawDataBase64,
String lastTxSignature, String programId
) {
byte[] bytes = Base64.getDecoder().decode(rawDataBase64);
if (bytes.length < 13 || bytes[0] != 1 || bytes[1] != 0) {
throw new IllegalArgumentException("Not a namespace PDA 1.0");
}
Reader r = new Reader(bytes);
r.readU8(); r.readU8();
int type = r.readU8();
if (type != 1 && type != 2) throw new IllegalArgumentException("Invalid namespace type");
int minLen = r.readU8();
String namespace = r.readStringU8();
if (!namespace.matches("[a-z0-9_]+") || minLen < 1 || namespace.length() + minLen + 1 > 30) {
throw new IllegalArgumentException("Invalid namespace");
}
byte[] feeLittleEndian = r.readFixed(8);
byte[] feeBigEndian = new byte[9];
for (int n = 0; n < 8; n++) feeBigEndian[8 - n] = feeLittleEndian[n];
java.math.BigInteger fee = new java.math.BigInteger(feeBigEndian);
String registrarKey = null, serverLogin = null;
if (type == 2) {
registrarKey = Base58Util.encode(r.readFixed(32));
serverLogin = r.readStringU8();
if (!serverLogin.matches("[A-Za-z0-9_]+@[a-z0-9_]+") || serverLogin.length() > 30) {
throw new IllegalArgumentException("Invalid access server login");
}
}
if (r.remaining() != 0 || !pdaAddress.equals(SolanaPdaUtil.findNamespacePda(namespace, programId))) {
throw new IllegalArgumentException("Invalid namespace bytes or PDA address");
}
return new NamespaceSnapshot(namespace, pdaAddress, type, minLen,
fee, registrarKey, serverLogin, slot, lastTxSignature, rawDataBase64);
}
public record NamespaceSnapshot(
String namespace, String pdaAddress, int type, int minLocalpartLength,
java.math.BigInteger registrationFeeLamports, String registrarPublicKey,
String defaultServerLogin, long slot, String lastTxSignature,
String rawDataBase64
) {}
public enum TxKind {
INIT_USERS_ECONOMY_CONFIG,
UPDATE_USERS_ECONOMY_CONFIG,
CREATE_USER_PDA,
CREATE_NAMESPACE,
UPDATE_USER_PDA,
CLOSE_LEGACY_USER_PDA,
OTHER
@@ -386,6 +386,7 @@ public final class SolanaUsersSyncService
);
storage.applyHistoryBatch(
List.of(),
List.of(),
List.of(),
newState
@@ -452,6 +453,7 @@ public final class SolanaUsersSyncService
List<ShineUsersCodec.UserPdaSnapshot> snapshotsToPersist =
new ArrayList<>();
List<ShineUsersCodec.NamespaceSnapshot> namespacesToPersist = new ArrayList<>();
ShineUsersCodec.EconomyConfigState economyState =
state.economyConfigState();
@@ -528,15 +530,19 @@ public final class SolanaUsersSyncService
SolanaRpcClient.AccountBatchResult exactAccounts =
rpcClient.getCurrentAccounts(exactFetchPdaAddresses, newestSeen.slot());
for (ProgramAccountUpdate account : exactAccounts.updates()) {
ShineUsersCodec.UserPdaSnapshot snapshot =
ShineUsersCodec.parseUserPdaAccount(
account.address(),
account.slot(),
account.dataBase64(),
latestRelevantSignatureByPda.getOrDefault(account.address(), "")
);
snapshotsToPersist.removeIf(existing -> existing.pdaAddress().equals(snapshot.pdaAddress()));
snapshotsToPersist.add(snapshot);
String lastSignature = latestRelevantSignatureByPda.getOrDefault(account.address(), "");
byte[] firstBytes = Base64.getDecoder().decode(account.dataBase64());
if (firstBytes.length > 2 && firstBytes[0] == 1 && firstBytes[1] == 0) {
var ns = ShineUsersCodec.parseNamespaceAccount(account.address(),
account.slot(), account.dataBase64(), lastSignature, config.programId());
namespacesToPersist.removeIf(existing -> existing.pdaAddress().equals(ns.pdaAddress()));
namespacesToPersist.add(ns);
} else {
var snapshot = ShineUsersCodec.parseUserPdaAccount(account.address(),
account.slot(), account.dataBase64(), lastSignature);
snapshotsToPersist.removeIf(existing -> existing.pdaAddress().equals(snapshot.pdaAddress()));
snapshotsToPersist.add(snapshot);
}
}
}
@@ -558,6 +564,7 @@ public final class SolanaUsersSyncService
storage.applyHistoryBatch(
txEntries,
snapshotsToPersist,
namespacesToPersist,
newState
);
@@ -595,6 +602,7 @@ public final class SolanaUsersSyncService
List<ShineUsersCodec.UserPdaSnapshot> currentSnapshots =
new ArrayList<>();
List<ShineUsersCodec.NamespaceSnapshot> currentNamespaces = new ArrayList<>();
int processedAccounts =
0;
@@ -604,14 +612,14 @@ public final class SolanaUsersSyncService
processedAccounts++;
try {
currentSnapshots.add(
ShineUsersCodec.parseUserPdaAccount(
account.address(),
account.slot(),
account.dataBase64(),
""
)
);
byte[] firstBytes = Base64.getDecoder().decode(account.dataBase64());
if (firstBytes.length > 2 && firstBytes[0] == 1 && firstBytes[1] == 0) {
currentNamespaces.add(ShineUsersCodec.parseNamespaceAccount(
account.address(), account.slot(), account.dataBase64(), "", config.programId()));
} else {
currentSnapshots.add(ShineUsersCodec.parseUserPdaAccount(
account.address(), account.slot(), account.dataBase64(), ""));
}
} catch (Exception ignored) {
}
@@ -654,6 +662,7 @@ public final class SolanaUsersSyncService
storage.replaceCurrentFromFullSnapshot(
currentSnapshots,
currentNamespaces,
newState
);
@@ -248,6 +248,7 @@ public final class PostgresStorageRepository
public synchronized void applyHistoryBatch(
List<TxHistoryEntry> txEntries,
List<ShineUsersCodec.UserPdaSnapshot> snapshots,
List<ShineUsersCodec.NamespaceSnapshot> namespaces,
SyncStateSnapshot newState
) throws Exception {
@@ -268,6 +269,7 @@ public final class PostgresStorageRepository
snapshots
);
upsertNamespaceSnapshots(connection, namespaces);
upsertCurrentSnapshots(
connection,
snapshots
@@ -297,6 +299,7 @@ public final class PostgresStorageRepository
public synchronized void replaceCurrentFromFullSnapshot(
List<ShineUsersCodec.UserPdaSnapshot> snapshots,
List<ShineUsersCodec.NamespaceSnapshot> namespaces,
SyncStateSnapshot newState
) throws Exception {
@@ -306,6 +309,7 @@ public final class PostgresStorageRepository
connection.setAutoCommit(false);
try {
upsertNamespaceSnapshots(connection, namespaces);
upsertCurrentSnapshots(
connection,
snapshots
@@ -459,6 +463,39 @@ public final class PostgresStorageRepository
}
}
private void upsertNamespaceSnapshots(Connection connection,
List<ShineUsersCodec.NamespaceSnapshot> namespaces) throws Exception {
if (namespaces == null || namespaces.isEmpty()) return;
String sql = """
INSERT INTO shine_namespace_current (
namespace, pda_address, namespace_type, min_localpart_len,
registration_fee_lamports, registrar_pubkey, default_server_login,
slot, last_tx_signature, raw_data_base64
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
ON CONFLICT (namespace) DO UPDATE SET
slot=EXCLUDED.slot, last_tx_signature=EXCLUDED.last_tx_signature,
raw_data_base64=EXCLUDED.raw_data_base64
WHERE shine_namespace_current.pda_address=EXCLUDED.pda_address
AND shine_namespace_current.raw_data_base64=EXCLUDED.raw_data_base64
""";
try (PreparedStatement ps = connection.prepareStatement(sql)) {
for (ShineUsersCodec.NamespaceSnapshot ns : namespaces) {
ps.setString(1, ns.namespace()); ps.setString(2, ns.pdaAddress());
ps.setInt(3, ns.type()); ps.setInt(4, ns.minLocalpartLength());
ps.setBigDecimal(5, new java.math.BigDecimal(ns.registrationFeeLamports()));
ps.setString(6, ns.registrarPublicKey());
ps.setString(7, ns.defaultServerLogin()); ps.setLong(8, ns.slot());
ps.setString(9, ns.lastTxSignature()); ps.setString(10, ns.rawDataBase64());
ps.addBatch();
}
ps.executeBatch();
}
// Namespace появляется после сервера, пересчитываем маршруты free пользователей.
try (Statement st = connection.createStatement()) {
st.execute("SELECT shine_refresh_user_access_servers_all()");
}
}
private void upsertCurrentSnapshots(
Connection connection,
List<ShineUsersCodec.UserPdaSnapshot> snapshots
@@ -1076,6 +1113,16 @@ public final class PostgresStorageRepository
"ON user_access_servers_current(server_login)"
);
// После PostgreSQL migration_v33 функции маршрутизации принадлежат
// общему реестру логических identity, их нельзя перезаписывать
// legacy Solana-only вариантом при старте sync.
boolean hasIdentityTable;
try (ResultSet check = statement.executeQuery(
"SELECT to_regclass('user_identity_current') IS NOT NULL")) {
check.next();
hasIdentityTable = check.getBoolean(1);
}
if (!hasIdentityTable) {
statement.execute(
"""
CREATE OR REPLACE FUNCTION shine_refresh_user_access_servers_for_user(p_user_login TEXT)
@@ -1260,6 +1307,8 @@ public final class PostgresStorageRepository
"EXECUTE FUNCTION trg_refresh_user_access_servers_from_user_pda_truncate()"
);
}
statement.execute("SELECT shine_refresh_user_access_servers_all()");
}
}
@@ -61,6 +61,27 @@ public final class SolanaPdaUtil {
);
}
/** Новый v2 PDA. Старый двух-seed вариант оставлен только для legacy accounts. */
public static String findUserPdaV2(String fullLogin, String programId) {
if (fullLogin == null || !fullLogin.matches("[A-Za-z0-9_]+@[a-z0-9_]+") || fullLogin.length() > 30) {
throw new IllegalArgumentException("Invalid full login");
}
return findHashedPda("user_login=" + fullLogin.toLowerCase(java.util.Locale.ROOT), programId);
}
public static String findNamespacePda(String namespace, String programId) {
if (namespace == null || !namespace.matches("[a-z0-9_]+")) {
throw new IllegalArgumentException("Invalid namespace");
}
return findHashedPda("namespace=" + namespace, programId);
}
private static String findHashedPda(String preimage, String programId) {
SHA256.Digest digest = new SHA256.Digest();
byte[] seed = digest.digest(preimage.getBytes(StandardCharsets.UTF_8));
return findProgramAddress(List.of(seed), programId);
}
private static byte[] createProgramAddress(
List<byte[]> seeds,
byte[] programId
@@ -0,0 +1,35 @@
package sync.codec;
import sync.util.SolanaPdaUtil;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Base64;
import java.util.HexFormat;
import java.util.Properties;
/** Отдельная offline-проверка, без RPC/DB; запуск через main(). */
public final class NamespaceV2VectorCheck {
public static void main(String[] args) throws Exception {
Properties p = new Properties();
try (var stream = Files.newInputStream(Path.of(args[0]))) { p.load(stream); }
String program = p.getProperty("program_id");
if (!p.getProperty("namespace_free_pda").equals(SolanaPdaUtil.findNamespacePda("free", program)))
throw new AssertionError("Namespace seed/PDA mismatch");
if (!p.getProperty("user_bob_free_pda").equals(SolanaPdaUtil.findUserPdaV2("bob@free", program)))
throw new AssertionError("User v2 seed/PDA mismatch");
byte[] raw = HexFormat.of().parseHex(p.getProperty("namespace_free_bytes_hex"));
var ns = ShineUsersCodec.parseNamespaceAccount(p.getProperty("namespace_free_pda"),
42, Base64.getEncoder().encodeToString(raw), "test-signature", program);
if (!"free".equals(ns.namespace()) || ns.type() != 2 ||
ns.registrationFeeLamports().longValueExact() != 5_000_000L ||
!"registrar@shine".equals(ns.defaultServerLogin()))
throw new AssertionError("Namespace value mismatch");
byte[] corrupt = raw.clone(); corrupt[6] ^= 1;
try {
ShineUsersCodec.parseNamespaceAccount(p.getProperty("namespace_free_pda"),
42, Base64.getEncoder().encodeToString(corrupt), "test-signature", program);
throw new AssertionError("Wrong PDA accepted");
} catch (IllegalArgumentException expected) { }
System.out.println("PASS: Java namespace decoder & SHA256 PDA test vectors");
}
}
@@ -24,4 +24,13 @@ class SolanaPdaUtilTest {
pda
);
}
@Test
void mixedCaseUsesSamePdaButNamespaceMustRemainLowercase() {
String program = "SHiNEPr1APdAgNBteUyBXcNovaHctpSjUu8oH2ZJdN6";
String lower = SolanaPdaUtil.findUserPdaV2("superman@free", program);
assertEquals(lower, SolanaPdaUtil.findUserPdaV2("SuperMan@free", program));
assertEquals(lower, SolanaPdaUtil.findUserPdaV2("SUPERMAN@free", program));
org.junit.jupiter.api.Assertions.assertThrows(IllegalArgumentException.class,
() -> SolanaPdaUtil.findUserPdaV2("SuperMan@FREE", program));
}
}
@@ -9,6 +9,7 @@ import org.eclipse.jetty.websocket.server.config.JettyWebSocketServletContainerI
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import server.archive.ArweaveBlockPublisherScheduler;
import server.archive.registration.FreeRegistrationApiBootstrap;
import server.archive.ArweaveBlockSyncScheduler;
import server.debug.DebugApiConfigurator;
import server.files.DmFileApiConfigurator;
@@ -18,6 +19,7 @@ import server.sync.PeriodicDmDeliveryService;
import server.sync.SolanaUsersSyncStartupService;
import server.sync.SyncServersBootstrapService;
import server.sync.ServerConnectionPool;
import shine.db.DbController;
import utils.config.AppConfig;
import java.time.Duration;
@@ -34,7 +36,14 @@ public final class WsServer {
public static void main(String[] args) throws Exception {
// ============================================================
// 1.0) Синхронизация пользовательских Solana PDA
// 1.0) Сначала создаём полную runtime-схему SHiNE.
// Solana sync использует ту же БД и создаёт собственные таблицы;
// без этого порядка чистая БД ошибочно выглядит для runtime как legacy.
// ============================================================
DbController.getInstance();
// ============================================================
// 1.1) Синхронизация пользовательских Solana PDA
// ============================================================
SolanaUsersSyncStartupService.startOrThrow();
@@ -65,6 +74,7 @@ public final class WsServer {
// PeriodicBlockchainSyncService is retained only as deprecated historical code.
// ANS-104: publish locally-created signed user blocks and discover blocks published by other servers.
FreeRegistrationApiBootstrap.startOrThrow();
ArweaveBlockPublisherScheduler.startOrLog();
ArweaveBlockSyncScheduler.startOrLog();
KeyRotationRebuildScheduler.startOrLog();
@@ -104,7 +114,7 @@ public final class WsServer {
log.info("✅ WS сервер запущен на ws://localhost:{}/ws", port);
ServerConnectionPool.getInstance().startOrLog();
Runtime.getRuntime().addShutdownHook(new Thread(
() -> { ServerConnectionPool.getInstance().close(); ArweaveBlockPublisherScheduler.close(); ArweaveBlockSyncScheduler.close(); },
() -> { ServerConnectionPool.getInstance().close(); ArweaveBlockPublisherScheduler.close(); ArweaveBlockSyncScheduler.close(); FreeRegistrationApiBootstrap.close(); },
"server-connection-pool-shutdown"));
PeriodicDmDeliveryService.startOrLog();
server.join();
@@ -146,7 +146,7 @@ test.freeAvatar.walletJwkPath=
# ============================================================
# Arweave per-user-block transport (ANS-104)
# Test namespace: each user DataItem is signed with App=test5591.
# Test namespace: each user DataItem is signed with App=test5592.
# Channel DataItems additionally contain c=<canonical-channel-slug>.
# ============================================================
arweave.blocks.publish.enabled=false
+2 -2
View File
@@ -1,2 +1,2 @@
client.version=1.20.0
server.version=1.16.0
client.version=1.20.12
server.version=1.16.11
+42 -2
View File
@@ -5,7 +5,7 @@
## Что уже есть
- основной сервер запускает `SolanaUsersSyncStartupService` до продолжения startup;
- основной сервер сначала инициализирует полную PostgreSQL runtime-схему SHiNE, затем запускает `SolanaUsersSyncStartupService` до продолжения startup;
- модуль синхронизации держит актуальными таблицы:
- `solana_sync_state`
- `solana_sync_tx_history`
@@ -56,7 +56,7 @@ psql \
-f SHiNE-server/shine-server-db/src/main/resources/postgres/schema_v1.sql
```
Скрипт предназначен **только для полностью пустой PostgreSQL схемы**. На старой/непустой базе он завершится ошибкой и не выполняет in-place migration.
Скрипт предназначен **только для полностью пустой PostgreSQL схемы**. На старой/непустой базе он завершится ошибкой и не выполняет in-place migration. При обычном первом запуске вручную выполнять его не нужно: сервер сам первым создаёт полную runtime-схему, и только затем стартует Solana sync; это не даёт sync-таблицам ошибочно выглядеть как legacy-БД.
Скрипт:
@@ -125,3 +125,43 @@ Migration v26 добавляет server-local поля `rotation_status` / `rota
## Миграции key rotation
При обновлении сервера DatabaseInitializer последовательно применяет migration v26 (state machine смены ключей) и v27 (отдельные candidate-блоки будущего fork). Ручного создания таблиц не требуется. Candidate-блоки не входят в текущую таблицу `blocks` до финального переключения fork.
## Этапы регистрации V2 4–7: подготовка тестового окружения (23.10.2026)
Перед запуском новой синхронизации нужен тестовый `shine_users` (opcode 7, namespace accounts), применённая PostgreSQL v33, бэкап и отдельная БД. Только после этого разрешён импорт namespace в отдельный регистр `shine_namespace_current`. Не совмещать с существующим UI/production. `freeRegistration.enabled` по умолчанию false; `freeRegistration.registrarSeedFile` — локальный secret path (Base64 seed32) вне Git. При несоответствии регистратора публичному ключу on-chain namespace выдача сертификата прекращается. Нет Arweave importer до этапа 8, API/UI до этапов 9–10. Сначала прогоните чистый snapshot, историю, restart/replay, FK и ключевую ротацию на тестовом контуре.
## DB v35: единый платный статус (26.10.2026)
`DatabaseInitializer` при запуске сервера последовательно обновляет схему до v35. Старые
`PAID_DIRECT` и `PAID_UPGRADED` преобразуются в единый `PAID`; `FREE_CERT` не изменяется.
Любой новый пользователь с настоящей PDA Solana получает `PAID` независимо от способа регистрации.
Данные аккаунтов, Arweave-сертификаты, начальная дата регистрации и ключи не удаляются.
Порядок на тестовом контуре: резервная копия БД → обновление серверного кода с `migration_v35.sql`
→ перезапуск и проверка `db_schema_version=35` → обновление UI → пробная регистрация и upgrade.
До обновления сервера или при неудачной миграции оставьте существующий UI: новое значение `PAID`
должно приходить только от сервера с применённой v35. На production — отдельное согласование.
Для проверки статусов после миграции:
```sql
SELECT registration_status, count(*) FROM user_identity_current GROUP BY registration_status;
SELECT schema_version FROM db_schema_version WHERE id=1;
```
## Регистронезависимый логин (2026-10-28)
Для новых баз важно совместное обновление программы `shine_users`, Java Solana sync/архива и UI. После обновления `login` внутри PDA сохраняет регистр, а адрес и `normalized_login` используют lowercase. Перед проверкой смешанного регистра заново инициализируйте **тестовую** БД и разверните обновлённую Solana-программу в devnet; сам ZIP её не разворачивает.
## 2026-10-28 — Неизменяемый регистр логина (PostgreSQL v37)
- В `user_identity_current.login` хранится **написание первой регистрации**, включая заглавные буквы. В `normalized_login` — его lowercase-форма для поиска и уникальности.
- v37 добавляет BEFORE INSERT/UPDATE-проверку: `normalized_login = lower(btrim(login))`, а после создания идентичности оба поля неизменяемы.
- `shine_sync_identity_from_solana()` отклоняет PDA, если для того же нормализованного имени его `login` не совпадает **точно** с Arweave-сертификатом или предыдущей регистрацией. При FREE_CERT → PAID нельзя изменять только регистр.
- Сервер перед первым `AddBlock` сверяет HEADER с точным `user_identity_current.login`; нормализованное имя цепочки этому не противоречит.
- Никакого преобразования существующих signed-блоков нет; новая тестовая эпоха создаётся с чистой БД и без старых HEADER.
## PostgreSQL v38: ключ blockchain state
После обновления сервера `DatabaseInitializer` автоматически применит migration v38 и при старте нормализует `blockchain_state_store.blockchain_key` из исторического Base58 в Base64(32). Ручной SQL-апдейт для free-пользователей не нужен. После запуска проверьте, что первый `AddBlock` нового free-пользователя проходит без `BAD_BLOCKCHAIN_KEY_LEN`.
+2 -1
View File
@@ -65,7 +65,8 @@ rsync -a "$SRC_DIR"/ "$TMP_DIR"/
DEPLOY_CONFIG_FILE="$TMP_DIR/js/deploy-config.js"
if [[ -f "$DEPLOY_CONFIG_FILE" ]]; then
if [[ -n "$DEPLOY_SERVER_LOGIN" ]]; then
perl -0pi -e "s/export const defaultServerLogin = '.*?';/export const defaultServerLogin = '$DEPLOY_SERVER_LOGIN';/s" "$DEPLOY_CONFIG_FILE"
export DEPLOY_SERVER_LOGIN
perl -0pi -e 's/export const defaultServerLogin = '\''[^'\'']*'\'';/export const defaultServerLogin = '\''$ENV{DEPLOY_SERVER_LOGIN}'\'';/' "$DEPLOY_CONFIG_FILE"
fi
if [[ -n "$DEPLOY_SERVER_ADDRESS" ]]; then
perl -0pi -e "s/export const defaultServerAddress = '.*?';/export const defaultServerAddress = '$DEPLOY_SERVER_ADDRESS';/s" "$DEPLOY_CONFIG_FILE"
+1 -1
View File
@@ -5,7 +5,7 @@ REMOTE_HOST="player@t2.shineup.me" \
REMOTE_UI_DIR="/home/player/t2/UI" \
EXPECTED_CADDY_UI_ROOT="/home/player/t2/UI" \
EXPECTED_CADDY_SITE="t2.shineup.me" \
DEPLOY_SERVER_LOGIN="server_t2" \
DEPLOY_SERVER_LOGIN="server_t2@shine" \
DEPLOY_SERVER_ADDRESS="t2.shineup.me" \
DEPLOY_SOLANA_CLUSTER="devnet" \
DEPLOY_SOLANA_ENDPOINT="https://devnet.helius-rpc.com/?api-key=0614c894-52d8-4ddc-bbbc-0947ce5ec3a4" \
+1 -1
View File
@@ -5,7 +5,7 @@ REMOTE_HOST="player@t3.shineup.me" \
REMOTE_UI_DIR="/home/player/t3/UI" \
EXPECTED_CADDY_UI_ROOT="/home/player/t3/UI" \
EXPECTED_CADDY_SITE="t3.shineup.me" \
DEPLOY_SERVER_LOGIN="server_t3" \
DEPLOY_SERVER_LOGIN="server_t3@shine" \
DEPLOY_SERVER_ADDRESS="t3.shineup.me" \
DEPLOY_SOLANA_CLUSTER="devnet" \
DEPLOY_SOLANA_ENDPOINT="https://devnet.helius-rpc.com/?api-key=0614c894-52d8-4ddc-bbbc-0947ce5ec3a4" \
+8
View File
@@ -171,3 +171,11 @@
- `GetUser` — проверка существования пользователя на сервере.
- `SearchUsers` — временный поиск пользователей по префиксу.
- Регистрация выполняется только через Solana.
## Регистрация V2: полные логины и независимые проверки
Публичные WS-операции нового протокола перечислены в `docs/registration-v2/WS_REGISTRATION_V2_PROPOSED_NOT_ENABLED.md`.
Сначала `GetNamespaces` → `CheckRegistrationLogin` с полным `login@namespace`; затем **только для бесплатной регистрации** отдельное `CheckRegistrationEmail`. После проверки запускается `StartFreeRegistration`, затем `ConfirmFreeRegistration` с шестизначным одноразовым кодом из письма (1 час, 5 попыток). Состояние читается через `GetRegistrationStatus`.
Все бесплатные сертификаты подписаны ANS-104 и внутренней подписью Ed25519; успешный Turbo ACK не означает подтверждённую высоту Arweave. Клиент никогда не отправляет пароль или приватные ключи на сервер.
+2 -2
View File
@@ -32,14 +32,14 @@
- generic Ed25519 signature type `2`;
- Ed25519 signature 64 bytes;
- owner 32 bytes и равен текущему blockchain public key;
- обязательный тестовый tag `App=test5591`;
- обязательный тестовый tag `App=test5592`;
- для channel block — `c=<canonical_channel_slug>`;
- `TEXT_CHANNEL_DELETE (type=1/subType=92/version=1)` является обычным line-based channel block с пустым text и тем же обязательным `c=<slug>`; отдельной операции API для удаления канала нет;
- `data` содержит SHiNE Frame v1 (`frameCode=1`).
## Основные ошибки
- `bad_app_tag` — отсутствует/неверен `App=test5591`;
- `bad_app_tag` — отсутствует/неверен `App=test5592`;
- `bad_channel_tag` — `c` отсутствует, лишний или не совпадает с canonical slug;
- `bad_signature` / `signature_verify_failed` — DataItem не подписан текущим blockchain key;
- `bad_block_number` — нарушена последовательность;
+4
View File
@@ -642,3 +642,7 @@ Changing `account_role` or `shine` does not alter the raw reaction. The two qual
`ownerBlockchainName` и корневой блок позволяют клиенту открыть канонический канал через существующую маршрутизацию.
Неверные поля: HTTP-подобный статус `400`, код `BAD_FIELDS`; ошибки чтения БД: `SERVER_DATA_ERROR`, `DB_ERROR`.
Структура блокчейна не меняется. Индексы поиска добавлены миграцией БД v32 (`pg_trgm`).
## 2026-10-28 — Официальный регистр логинов при чтении
В ответах `GetChannelMessages`, `GetMessageThread`, `ListSubscriptionsFeed` поля `authorLogin` и `ownerLogin` показывают **регистрационное написание** из `user_identity_current`, например `AlexSmith@shine`. В БД блока и в `blockchainName` по-прежнему возможен lowercase, используемый как нормализованный идентификатор. Это не меняет имена JSON-полей или типы значений, а уточняет их семантику. Для поиска и переходов разные варианты регистра по-прежнему ссылаются на одну идентичность; байты уже подписанных блоков не переписываются.
+22
View File
@@ -95,3 +95,25 @@
- HTTP endpoints публичных content-addressed файлов (`PUT/GET/HEAD/OPTIONS /files/{sha256}`) также не являются WebSocket `op` и описаны отдельно в `21_Public_File_Storage_API.md`.
- Классы `Net_MarkChannelMessagesSeen_*` существуют в коде, но операция `MarkChannelMessagesSeen` не зарегистрирована в `JsonHandlerRegistry`, поэтому в публичный список API не входит.
- HTTP debug endpoints из `src/main/java/server/debug/` не входят в этот индекс WebSocket `op`; они описаны отдельно в `13_HTTP_Debug_API.md`.
## Registration V2 (добавлено 23.10.2026, test/dev only)
- `GetNamespaces` — список зарегистрированных namespace из Solana-синхронизации;
- `CheckRegistrationLogin` — отдельная проверка `login@namespace`;
- `CheckRegistrationEmail` — отдельная проверка email;
- `StartFreeRegistration` — запрос сертификата по трём публичным ключам;
- `ConfirmFreeRegistration` — подтверждение тестовым кодом и Turbo ACK;
- `GetRegistrationStatus` — статус и публичные поля сертификата для upgrade.
Точный JSON и ограничения: `docs/registration-v2/WS_REGISTRATION_V2_PROPOSED_NOT_ENABLED.md` (имя сохранено для обратных ссылок; внутри утверждённая версия).
### `GetRegistrationStatus` после DB v35
Для существующего пользователя `payload.registrationStatus` имеет одно из **двух** значений:
`FREE_CERT` (бесплатная регистрация Arweave) или `PAID` (подтверждённая PDA Solana).
`PAID` применяется и к первоначально платным, и к ранее бесплатным пользователям;
`NOT_FOUND` остаётся техническим ответом для отсутствующего логина.
Во время поэтапного развертывания старый сервер может ещё возвращать `PAID_DIRECT`
или `PAID_UPGRADED`; обновлённый UI понимает эти устаревшие ответы как платные.
Поля сертификата для `FREE_CERT` и остальные поля API не меняются.
+1 -1
View File
@@ -248,7 +248,7 @@
Если Solana sync успел увидеть новое PDA раньше вызова `KeyRotationRotatePda`, он умеет подтвердить ожидаемые ключи прямо из `CHAIN_READY`. Поэтому потеря клиентского запроса после уже подтверждённой Solana-транзакции не оставляет ротацию зависшей. Если API-вызов всё же приходит, handler идемпотентно возвращает текущее подтверждённое состояние.
Повтор с той же signature идемпотентен. Другая signature для уже начатого `ROTATING_PDA` возвращает conflict.
Повтор с той же signature идемпотентен: при `PDA_ROTATED`, `REBUILDING_SERVER`, `WALLET_MIGRATION`, `MESSAGE_MIGRATION` и `FINALIZING` возвращается актуальное состояние без ошибки 409. Это закрывает гонку Solana sync с уведомлением UI. Если signature ранее сохранена, конфликтующая signature возвращает conflict.
### Основные ошибки
+3 -1
View File
@@ -2,7 +2,9 @@
`GetMyBlockchain` — авторизованное постраничное чтение **только текущей активной версии собственного блокчейна**. API используется постоянным экраном «Мой блокчейн» и мастером смены ключей для выбора последнего доверенного блока.
Login и активный `blockchainName` сервер определяет из авторизованной сессии/current PDA; клиент не может запросить этим методом чужую цепочку.
Login сервер берёт только из авторизованной пользовательской сессии. Активное `blockchainName` определяется через общий реестр `user_identity_current` (DAO `CurrentUsersDAO`): для `PAID` он синхронизирован с Solana, для `FREE_CERT` — с проверенным сертификатом Arweave. Наличие пользовательского Solana PDA **не требуется** для чтения собственного блокчейна. Клиент не может запросить этим методом чужую цепочку.
У только что зарегистрированного пользователя до первого `HEADER` может отсутствовать запись с блоками: тогда при существующей идентичности возвращается `status=200`, `tipBlockNumber=-1`, `blocks=[]`, а не `BLOCKCHAIN_NOT_FOUND`. Ошибка `BLOCKCHAIN_NOT_FOUND` относится к отсутствующему пользователю или отсутствующему в его записи имени блокчейна; отсутствие блоков само по себе не является ошибкой. Это изменение внутреннего источника поиска, **без изменения JSON-полей, op или кодировки блоков**.
## Request
+2 -2
View File
@@ -74,7 +74,7 @@ blockN.back32Hash32 = (N < 32 ? ZERO_HASH_32 : HASH(block N-32))
Каждый блок:
```text
App = test5591
App = test5592
```
Это временное namespace-значение для разработки. Перед реальным запуском оно будет заменено отдельным изменением протокола/кода.
@@ -120,7 +120,7 @@ Slug входит в подпись DataItem и не может быть изм
Сервер обязан:
1. распарсить полный ANS-104 DataItem;
2. проверить `App=test5591`;
2. проверить `App=test5592`;
3. проверить `t`, если тип блока требует фиксированный индексный поток;
4. проверить `c`, если тип блока требует канал;
5. проверить ANS-104 Ed25519 подпись;
+6
View File
@@ -14,10 +14,16 @@ t=tech
Стартовый блок цепочки (`block #0`). Payload содержит tag `SHiNE`, login владельца и `initialBlockchainKey32`.
Поле `login` хранит **точное неизменяемое написание идентичности при регистрации**: для новой регистрации `login@namespace` соответствует `[A-Za-z0-9_]+@[a-z0-9_]+`, длина не более 30 байт. Регистр локальной части сохраняется побайтно из Solana PDA или сертификата Arweave; `@namespace` остаётся строчным. `AlexSmith@shine` и `alexsmith@shine` идентифицируют одного человека (по lower-case), но только первый вариант допустим в его HEADER, если именно так он зарегистрирован. `@` не меняет бинарную структуру HEADER: `[loginLength:uint8][login UTF-8 bytes]`. При копировании префикса для следующих fork первый HEADER не меняется. Исторические legacy `[A-Za-z0-9_]+` по-прежнему декодируются, но в новую регистрацию не допускаются.
AddBlock сверяет HEADER #0 с точным именем в `user_identity_current` и не принимает отличия в регистре. Другие блоки со ссылками на пользователей разрешается адресовать независимо от регистра. Новые UI-блоки (ответы, реакции, оценки, статусы, связи, подписки, репосты) должны записывать официальный регистр, полученный через `GetUser`, **перед** подписью. Нормализация используется в поиске/сопоставлении и при построении имени цепочки, но не для изменения подписанного текста.
`initialBlockchainKey32` — public blockchain-signing key, которым был создан fork №1; это историческая точка происхождения. При последующих fork значение не меняется.
HEADER сам не хранит line-prefix, но является root TECH-линии.
После успешной регистрации и автоматического входа клиент вызывает `ensureBlockchainHeader(login, storagePwd)` один раз в общем завершении регистрации (как Solana, так и Arweave). При отсутствии блока №0 клиент создаёт и подписывает HEADER и отправляет его через обычный `AddBlock`. Неудачная отправка **не отменяет** уже подтверждённую регистрацию: существующая логика создания первого пользовательского блока проверит и при необходимости создаст HEADER перед ним. Дополнительной проверки при каждом входе нет. Формат блоков и серверный API не изменены.
### `subType=1` — `TECH_CREATE_CHANNEL`
Создание нового канала. Блок одновременно:
@@ -1,6 +1,6 @@
# ANS-104 / Arweave transport для пользовательских блоков SHiNE
> **Текущий transport namespace:** `test5591`. Он намеренно хранится отдельно в трёх рабочих местах: сервер (`ShineProtocolTags.java`), UI (`js/services/protocol-tags.js`) и актуальный Viewer (`static-sites/arweave-viewer/index.html`). При смене тестовой эпохи эти три значения меняются синхронно. Имя канального индексного тега постоянно и не зависит от namespace: `c`.
> **Текущий transport namespace:** `test5592`. Он намеренно хранится отдельно в трёх рабочих местах: сервер (`ShineProtocolTags.java`), UI (`js/services/protocol-tags.js`) и актуальный Viewer (`static-sites/arweave-viewer/index.html`). При смене тестовой эпохи эти три значения меняются синхронно. Подписанные бесплатные сертификаты `t=reg` используют ту же серверную константу `ShineProtocolTags.APP_TAG_VALUE` (отдельного жёстко заданного App тега нет). Имя канального индексного тега постоянно и не зависит от namespace: `c`.
## Цель
@@ -13,7 +13,7 @@
Для тестового контура обязательно:
```text
App=test5591
App=test5592
```
Для фиксированных потоков:
@@ -94,7 +94,7 @@ Bundle-Version=2.0.0
Content-Type=application/octet-stream
```
Специальный `App=test5591-batch` больше не используется. Важны вложенные user DataItems, у которых уже есть `App=test5591`.
Специальный `App=test5592-batch` больше не используется. Важны вложенные user DataItems, у которых уже есть `App=test5592`.
### `none`
@@ -114,7 +114,7 @@ Content-Type=application/octet-stream
Importer всегда выполняет один discovery-запрос:
```text
App=test5591
App=test5592
```
Он **не ищет root bundles** и не зависит от `publish.mode`.
@@ -132,7 +132,7 @@ App=test5591
Поэтому importer:
1. получает `data_item_id` через GraphQL `App=test5591`;
1. получает `data_item_id` через GraphQL `App=test5592`;
2. запрашивает `GET /ar-io/offsets/{data_item_id}`;
3. получает `rootTxId`, `rootOffset`, `size`;
4. делает range-read `GET /raw/{rootTxId}` ровно по этому диапазону;
+11
View File
@@ -0,0 +1,11 @@
# Единый идентификатор пользователя и оригинальный регистр (28.10.2026)
- `login@namespace`: `login` разрешает ASCII `A-Z`, `a-z`, цифры, `_`; namespace только `a-z`, цифры, `_`.
- Для сравнения, поиска, авторизации, PDA и имени блокчейна (`lower(fullLogin)-001`) используем ASCII lowercase.
- Сертификат Arweave подписывает исходное, неизменяемое написание. PDA хранит исходное написание; seed PDA строится из lowercase.
- В подписанных блоках лайков, ответов, оценок, статусов, подписок, репостов и связей формат **не меняется**. `toLogin` может содержать любой регистр, и это не создаёт другую идентичность. Новый UI **обязан** записывать в такие ссылки официальное написание из `GetUser` до подписи.
- В БД проекция статистики реакций, ответов и связей нормализует ссылки через `lower()`, не изменяя подписанное содержимое `blocks_store`.
- Для показа красивого имени UI использует исходное написание из регистрационной записи (`GetUser`), если оно ещё неизвестно по записи автора.
- Начальная установка делается на новой базе; миграция старых данных не предусмотрена.
- HEADER #0 всегда содержит исходный регистр из первой регистрации; сервер проверяет его точное совпадение. После создания пользователя регистр нельзя изменить ни в интерфейсе, ни во время FREE_CERT → Solana sync (PostgreSQL v37).
+35
View File
@@ -1,3 +1,10 @@
## 2026-10-28 — Новая тестовая эпоха Arweave `test5592`
- Текущий ANS-104 `App` изменён с `test5591` на `test5592`: UI, Java-сервер (включая бесплатные `t=reg` сертификаты), Arweave Viewer.
- Старые Arweave DataItem остаются неизменными, но не импортируются новой тестовой эпохой. Система стартует с новой PostgreSQL БД и очищенной программой shine_users на devnet.
- `App` — **тег Arweave**, а НЕ Solana Program ID. Program ID и `c=<slug>` не изменены.
- Исторические подписанные криптографические фикстуры `test5591` не переписываются; отдельно тестируется генерация новых `test5592`.
## 2026-10-06 18:02 +0300 — Soft-delete каналов
- Базовый коммит-ориентир: `working tree`; изменение подготовлено как patch без нового git-коммита.
@@ -318,3 +325,31 @@
- Экран «Мой блокчейн» теперь запрашивает уже существующее поле `blockBytesB64` и разбирает полный ANS-104 DataItem / SHiNE Frame v1 непосредственно в браузере.
- Для текущих TECH/TEXT/REACTION/CONNECTION/USER_PROFILE/STATUS_ACTION событий добавлены человекочитаемые подписи, компактный preview и раскрываемые детали.
- Arweave DataItem ID вычисляется локально как `SHA-256(signature64)` и используется для ссылки `https://arweave.net/<DataItemID>`.
- 2026-10-23 (без commit hash, ZIP patch): подготовлен код выдачи независимого `t=reg` ANS-104 DataItem (stage 7); существующий формат пользовательского блокчейна не изменён, деплой/Arweave публикация не выполнены.
- 2026-10-23 — архив регистрирует отдельные `t=reg` DataItem (формат существующих BchBlock без изменений); исправление/дополнение в некоммитированном архивном патче 0–10, commit hash отсутствует; после коммита добавить hash.
- 2026-10-23 — регистрационные WS операции и UI для отдельного `t=reg` ANS-104 DataItem, пользовательский Frame V1/AddBlock формат не менялся. Commit hash отсутствует (не коммитировалось), перед merge заменить на реальный hash.
- 2026-10-23 — исправлена валидация `HeaderBody`: кроме legacy-логинов разрешены `login@namespace` (до 30 ASCII-байт). Это устраняет `BAD_BLOCK_FORMAT` при первом AddBlock новых free/paid пользователей. Порядок байт HEADER, Frame v1, ANS-104 и API без изменений. Commit hash отсутствует (патч без git-коммита); после коммита добавить хэш.
- 2026-10-28: регистронезависимая идентичность и социальные ссылки; бинарный формат подписанных блоков не менялся. Коммит: не создавался (ZIP-патч).
## 2026-10-28 — Неизменяемый регистр регистрационного логина (патч без коммита)
- `HEADER #0` хранит регистр логина из Solana PDA/Arweave сертификата; AddBlock проверяет точное совпадение, не меняя бинарный формат.
- Ссылки создаваемых UI подписанных блоков содержат подтверждённое регистрационное написание; при чтении/поиске адресация остаётся case-insensitive.
- PostgreSQL v37 запрещает изменение `login` и `normalized_login` существующей идентичности и проверяет точный регистр при upgrade FREE_CERT → Solana.
- База для тестов новая, поддержка устаревшего HEADER с принудительным lowercase не добавляется. Git commit: не создавался (архив патча).
- Чтение GetChannelMessages, GetMessageThread и ListSubscriptionsFeed теперь выдаёт регистр авторов по регистрационной записи (с per-request кэшем), а не по lowercase имени цепочки.
## 2026-10-29 — Runtime-ключ состояния блокчейна
- Коммит `f507bdb3`: формат пользовательского блока не изменён. Для runtime `blockchain_state_store` закреплён ключ Base64(32); startup-миграция v38 нормализует ошибочно сохранённые Base58 ключи free-пользователей.
## 2026-10-29 — Автоматическое создание HEADER после регистрации
- Клиент после успешного входа непосредственно по завершении регистрации Solana/Arweave вызывает существующий `ensureBlockchainHeader`, чтобы сразу записать блок №0.
- Ошибка создания HEADER не отменяет регистрацию; прежняя страховка перед первым публикуемым блоком остаётся. Проверка при каждом входе не добавлялась.
- Формат блоков и серверный API не менялись. Коммит: `2ce80eea`.
@@ -1,4 +1,4 @@
> **LEGACY / historical patch note.** Current protocol uses `App=test5591` and the permanent channel tag `c=<slug>`. Do not apply the `c_test5590` instructions below to current code.
> **LEGACY / historical patch note.** Current protocol uses `App=test5592` and the permanent channel tag `c=<slug>`. Do not apply the `c_test5590` instructions below to current code.
# Применение patch: Turbo + direct Arweave для `App=test5590`
+12 -3
View File
@@ -15,7 +15,7 @@
```text
User
-> создаёт Frame v1
-> tags: App=test5591; t=tech/conn/prof для фиксированных потоков; при канале c=<slug>
-> tags: App=test5592; t=tech/conn/prof для фиксированных потоков; при канале c=<slug>
-> Ed25519 подписывает ANS-104 deep-hash
-> готовый DataItem
-> AddBlock
@@ -28,7 +28,7 @@ Server
ИЛИ publish.mode=none: наружу не публиковать
Other servers
-> GraphQL App=test5591
-> GraphQL App=test5592
-> скачивают/извлекают DataItem
-> verify
-> PostgreSQL без повторной публикации
@@ -39,4 +39,13 @@ Other servers
- SHiNE `prevHash` остаётся SHA-256 предыдущего Frame v1 и не зависит от Arweave.
- `data_item_id` нужен для Arweave, поиска и дедупликации.
- PostgreSQL — единственное локальное хранилище пользовательских блоков.
- Тестовый namespace `App=test5591` специально отделён от будущего production namespace.
- Тестовый namespace `App=test5592` специально отделён от будущего production namespace.
## Отдельные регистрационные DataItem V1 (test only; импорт реализован в коде, E2E не пройден)
Новая платформа регистрации `t=reg` использует ANS-104 Ed25519 и независимый payload, **не являющийся пользовательским AddBlock**. Формат определён в [регистрационном протоколе](../Протоколы/SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md). Обычный формат пользовательских блоков не меняется. Новая регистрация отправляет `t=reg` через Turbo и отдельный импортёр, код включён только в тестовом патче; фактический Turbo/GraphQL E2E ещё не пройден.
- Регистрационные Arweave ANS-104 DataItem `t=reg` (вне пользовательских блокчейнов): `../Протоколы/SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md`, `../registration-v2/PATCH_STAGES_8_9_10.md`.
- [Единая идентичность логина без учёта регистра](CASE_INSENSITIVE_LOGIN.md) — правила логинов, PDA и социальных ссылок (2026-10-28).
+1 -1
View File
@@ -40,7 +40,7 @@ blockchain.sync.enabled=false
Дополнительно каждый сервер может независимо включить `ArweaveBlockSyncScheduler`.
Он ищет child DataItems по тестовому тегу `App=test5591`, проверяет их и импортирует через ту же бизнес-проверку AddBlock. Импортированные блоки не публикуются повторно.
Он ищет child DataItems по тестовому тегу `App=test5592`, проверяет их и импортирует через ту же бизнес-проверку AddBlock. Импортированные блоки не публикуются повторно.
Если блоки обнаружены не по порядку, persistent queue оставляет более поздние блоки pending до появления предыдущих.
+24 -1
View File
@@ -17,7 +17,7 @@
На дату `2026-07-24` в основном сервере SHiNE уже есть серверная интеграция startup-уровня:
- сервер запускает sync-модуль до продолжения собственного startup;
- сервер сначала инициализирует полную PostgreSQL runtime-схему, затем запускает sync-модуль до продолжения собственного startup;
- server startup ждёт входа модуля в состояние `READY`;
- актуальный источник истины по пользователям для нового PostgreSQL runtime-слоя: `solana_user_pda_current`.
- для быстрого локального lookup единственного сервера доступа поддерживается
@@ -609,3 +609,26 @@ Create/update транзакции больше не реконструирую
Для каждого candidate DataItem сохраняются rotation session, login, candidate blockchain name, block number/hash, полный ANS-104 DataItem, DataItem id и статус публикации. Уникальность `(rotation_session_id, block_number)` запрещает две разные версии одного candidate-блока.
Arweave/Turbo publisher обрабатывает candidate-блоки приоритетно. `key_rotation_sessions.progress_current` отражает число DataItem, уже реально опубликованных publisher-ом, а не число принятых API-сервером.
## V2 регистрация — разработка (2026-10-23, этап 6, без развёртывания)
Для новых `login@namespace` используется `SHA256(UTF8("user_login=" + fullLogin))` как один 32-byte PDA seed; для namespace — `SHA256(UTF8("namespace=" + namespace))`. `IX_CREATE_NAMESPACE=7` читается как отдельное событие. `SolanaUsersSyncService` декодирует namespace независимо от user-PDA и сохраняет снапшоты namespaces в `shine_namespace_current`; paid user-PDA параллельно синхронизируются как прежде. При upsert Solana запись переносит логического пользователя `FREE_CERT → PAID` без изменения логина и исходной даты в `user_identity_current`; free-сертификат не превращается в фальшивый Solana PDA. Общий индекс появляется в DB v33. Миграция DB v35 консолидирует исторические `PAID_DIRECT`/`PAID_UPGRADED` в `PAID` и переопределяет Solana-trigger, чтобы все последующие PDA синхронизировались в одном платном статусе. `free_data_item_id` и `free_registration_certificate` остаются как свидетельства первоначальной бесплатной регистрации, но не создают особый статус. Standalone sync можно запускать только после применения миграций DB v33–v35 через Java-сервер.
**ВНИМАНИЕ:** проверить на настоящем PostgreSQL + RPC replay до включения. Read-only economy-PDA остаётся индексом истории через `getSignaturesForAddress`, не гарантирует websocket account notification.
## Логин с оригинальным регистром (2026-10-28)
При чтении PDA 1.2 `login` сохраняет регистр из подписанного on-chain состояния, а `normalized_login`/имя пользовательского блокчейна формируются из ASCII lowercase. Адрес PDA рассчитывается как `find_program_address(SHA256("user_login=" + ASCII-lowercase(fullLogin)))`; это предотвращает отдельные адреса для `SuperMan@free` и `superman@free`. Никаких переименований исторических данных нет — проект стартует с новой БД.
## 2026-10-28 — Неизменяемый регистр логина (PostgreSQL v37)
- В `user_identity_current.login` хранится **написание первой регистрации**, включая заглавные буквы. В `normalized_login` — его lowercase-форма для поиска и уникальности.
- v37 добавляет BEFORE INSERT/UPDATE-проверку: `normalized_login = lower(btrim(login))`, а после создания идентичности оба поля неизменяемы.
- `shine_sync_identity_from_solana()` отклоняет PDA, если для того же нормализованного имени его `login` не совпадает **точно** с Arweave-сертификатом или предыдущей регистрацией. При FREE_CERT → PAID нельзя изменять только регистр.
- Сервер перед первым `AddBlock` сверяет HEADER с точным `user_identity_current.login`; нормализованное имя цепочки этому не противоречит.
- Никакого преобразования существующих signed-блоков нет; новая тестовая эпоха создаётся с чистой БД и без старых HEADER.
## 2026-10-29 — Base64-ключ runtime blockchain state (PostgreSQL v38)
`blockchain_state_store.blockchain_key` является runtime-ключом для проверки `AddBlock` и хранится строго как Base64 от 32 байтов. Исходные ключи Solana PDA и free-сертификата могут оставаться в Base58 в identity-проекции; при создании blockchain state сервер записывает нормализованный Base64. Bootstrap v38 идемпотентно переводит уже сохранённые Base58-значения state в Base64.
@@ -0,0 +1,85 @@
# SHiNE Registration V2 — журнал выполнения
**Дата:** 23.10.2026
**Базовая версия:** `SHiNE-bundle-2026.10.23-12.36.02.zip` (SHA-256 `e2871bb11610437c354507dc9a723d64f14b0be4161af5f82d19f1466af648a6`)
**Исходная ветка/коммит:** не определены, потому что загруженный архив не содержит `.git`.
## Прогресс всех этапов (мастер-план V2, всего 14: 0–13)
| Этап | Название | Статус |
|---:|---|---|
| 0 | Исходный аудит, зависимости и baseline | **PARTIAL** — аудит и UI smoke выполнены, Rust/Gradle/DB baseline недоступны |
| 1 | Протоколы и межъязыковые тест-векторы | **PARTIAL** — V1 формат/векторы готов, Rust-тесты не запущены |
| 2 | Solana namespace PDA + upgrade authority | **PARTIAL** — Rust-код написан, сборка/localnet недоступны |
| 3 | Solana paid / certificate upgrade | **PARTIAL** — Rust-код написан, BPF/транзакции не тестировались |
| 4 | JS codecs + Solana client | **PARTIAL** — код нового контракта и unit-тесты есть, RPC/devnet не запускались |
| 5 | Unified PostgreSQL identity | **PARTIAL** — migration v33 написана, реального PostgreSQL integration нет |
| 6 | Java Solana sync | **PARTIAL** — namespace history/snapshot код, Java vector тест, нет Gradle/RPC/DB E2E |
| 7 | Сервер-регистратор и ключ подписи | **PARTIAL** — Java signer/certificate проходит offline; нет интеграции в lifecycle/Turbo |
| 8 | Arweave импорт + Turbo ACK | **PARTIAL** — importer / publisher / discovery; нет GraphQL/Turbo/DB E2E |
| 9 | WS/API free registration | **BLOCKED/PARTIAL** — internal workflow, публичный op требует отдельного утверждения |
| 10 | Auth и запреты FREE_CERT | **PARTIAL** — identity DAO / Solana lookup / guards, нет E2E |
| 11 | UI бесплатной и платной регистрации | NOT STARTED |
| 12 | UI free → paid upgrade | NOT STARTED |
| 13 | E2E/devnet и выпускная проверка | NOT STARTED |
## Этап №0 — 23.10.2026
1. **Поручено:** распаковать архив, изучить AGENTS.md, зафиксировать реальное состояние и baseline, найти идентификационные зависимости и SQL FK, завести журнал.
2. **Реально изменено:** только новые файлы `docs/registration-v2/IMPLEMENTATION_STATUS.md`, `docs/registration-v2/SOURCE_BASELINE.md`, `docs/registration-v2/SQL_DEPENDENCIES.md`. Не изменены Rust, Java, JS, SQL, тесты существующего проекта, `VERSION.properties`.
3. **Новые форматы / opcodes / миграции / конфиги:** нет. Разработка протокола v1 — задача этапа 1.
4. **Тесты:** `node --test shine-UI/tests/*.test.*` → **18 passed, 0 failed**; `node --check` трёх ключевых JS-файлов → **3 passed**; `javac --release 17` изолированного `CurrentUsersSql.java` → **успешно**; `./gradlew --version` → **BLOCKED** (нет доступа к `services.gradle.org` для Gradle 8.14); Rust/Cargo/Anchor/Solana CLI и PostgreSQL → **NOT RUN** (toolchain отсутствует).
5. **Ручная проверка:** исходники, `settings.rs`, UI guard, SQL FK, Java-current user facade, Solana sync/authorize пути и доступные тесты просмотрены. Архив распакован; система end-to-end не запускалась.
6. **Не сделано:** рабочая git-ветка/commit (нет `.git`); server/Solana/SQL baseline compile/integration; реальная сверка `pg_catalog` тестовой БД.
7. **Совместимость:** существующий пользовательский блокчейн, PDA, API, данные и файлы программы не изменены.
8. **Документация:** `SOURCE_BASELINE.md`, `SQL_DEPENDENCIES.md`, этот журнал.
9. **Коммиты/патч:** git commit не создавался, только экспортируемый patch архива этапа 0; не объявлять за выполненный production deployment.
10. **Риски:** 16 FK/15 таблиц к Solana current, SQL триггеры/функции маршрутов, real PDA-сессионные проверки, старый seed/normalization, нет полного toolchain; актуальный архив новее мастер-плана.
11. **Следующий этап:** завершить отсутствующие baseline тесты этапа 0 в подготовленной среде, затем №1 (байтовые протоколы namespace и сертификата с фиксированными тест-векторами).
12. **С чего читать:** `SOURCE_BASELINE.md` → `SQL_DEPENDENCIES.md` → мастер-план V2 (А, В, этапы 1–3) → `shine-solana/shine/AGENTS.md` → `shine_users/src/lib.rs`/`settings.rs` и документы форматов.
13. **Разрешения:** этап 0 не требует изменения публичного WS API или текущего формата blockchain. Перед фактическим изменением публичного API (этап 9) и текущего формата существующего blockchain (если станет необходимым) запросить предусмотренное `AGENTS.md` подтверждение. Production deploy не санкционирован.
**Правило статусов:** `PARTIAL` — не трактовать как `COMPLETED` и не считать, что проект уже поддерживает новую регистрацию. Для следующего сеанса сохранить эти три документа и исходный мастер-план V2 вместе с актуальным кодом.
## Объединённый патч этапов №1–3 — 23.10.2026
**Выполнение по запросу владельца проекта:** три последовательных этапа объединены **в один архив/патч**, хотя первоначальный план предлагал один этап на патч. Это не считается эксплуатационной готовностью.
1. **Исходный код:** `shine-solana/shine/programs/shine_users/src/lib.rs`, `settings.rs`: новый namespace PDA 1.0, `IX_CREATE_NAMESPACE=7`, ProgramData authority для namespace и economy update, новый SHA-256 user PDA для полного имени, Solana регистрация `PAID_DIRECT` и предъявление inner certificate для `PAID_UPGRADED`. Старый opcode 5 promo seller выключен; guard и promo из нового create удалены. Старые user PDA без namespace допускают прежний update и legacy close. Формат данных user PDA 1.2 не изменялся.
2. **Протоколы:** `shine-solana/shine/doc/formats/shine-namespace-pda-format-v1.md`; `docs/Протоколы/SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md`; документы программы и пользовательского PDA синхронизированы с переписанной реализацией.
3. **Фикстуры:** `tests/fixtures/registration-v2.json`, `.properties` с воспроизводимыми сырыми SHA-256, PDA+bump, Ed25519 inner message/signature, подписанным ANS-104 и двумя namespace binary; приватные пользовательские или серверные реальные ключи не включены.
4. **Тесты, РЕАЛЬНО выполнены:** `node --test shine-UI/tests/*.test.*` → **18/18**; `node --test shine-solana/shine/tests/registration-v2-*.test.mjs` → **9/9**; `javac --release 17` + автономная Java сверка PDA/SHA-256/Ed25519 → **OK**; `node --check` обеих scripts → **OK**; независимый decode бинарного namespace → **OK**.
5. **Не выполнены:** `cargo build`, `cargo test --test registration_v2_vectors`, `anchor build`, BPF, localnet/devnet smoke, negative cases authority mismatch, Solana transaction pay/create/update/upgrade. В окружении нет `cargo`/Rust toolchain и поднятой localnet. Статусы 2 и 3 **PARTIAL**, не COMPLETE.
6. **Не готовы и НЕ совместимы:** старый JS клиент, серверный Solana sync, PostgreSQL, WS API, UI регистрации — см. этапы 4–13; новая Solana программа **нельзя развёртывать с ними**. Требуются проверка ограничений на Solana compute/binary, связки treasury, регистрация сервера в paid namespace до namespace type2, тест восстановления и отсутствие начисления второго free-бонуса на upgrade.
7. **Влияние на production:** **НИКАКОГО**; запрос на deploy не поступал и не выполнялся. Git commit/push не выполнялись (.git в ZIP нет), VERSION.properties не изменялся — версия меняется по правилам перед отдельным commit.
8. **Следующая работа:** на полноценном Rust/Solana toolchain выполнить компиляцию, и негативные BPF/localnet тесты **до этапа 4**. Затем сделать этап 4: клиентский JS codec/account metas, с test fixtures; этапы 5–6: БД/синхронизация. После этих шагов можно начинать сервер-регистратор/WS/UI.
9. **Документ передачи:** этот журнал + `PATCH_STAGES_1_2_3.md` + вложенные копии мастер-плана/roadmap. Прежде чем принимать любое Solana изменение как завершённое, необходимо проверить его реальную работу и совместимость в testnet.
## 23 октября 2026: накопительный код этапов 4–7
- Поверх этапов 0–3 добавлены JS namespace client, DB миграция v33, Java Sync namespace codec, Java signer/certificate.
- Проверено локально: 23/23 UI Node; 6/6 Solana vectors Node; Java namespace и сертификат по независимым фикстурам.
- Блокеры: Rust toolchain/localnet, настоящий PostgreSQL, полная Gradle сборка/RPC replay. Архитектурный код **не равен готовности к развёртыванию**.
- Новая публичная WS операция отсутствует (отдельное согласование на этапе 9).
- Arweave/Turbo importer — этап 8; пока не реализован.
- Дальше: изолированная БД + localnet проверки, затем этап 8, далее API/UI.
- Документ: `PATCH_STAGES_4_5_6_7.md`.
## 23 октября 2026: накопительный код этапов 8–10
- Этап 8: новый `VerifiedFreeRegistrationImporter`, `FreeRegistrationPublisher`, GraphQL discovery отдельного `t=reg` и PostgreSQL миграция v34 для checkpoint; ACK Turbo и независимое Arweave подтверждение — разные события.
- Этап 9: Java `FreeRegistrationWorkflow` есть, но **новые публичные WS `op` не регистрировались** до отдельного согласования по `AGENTS.md`. Проект договора — `WS_REGISTRATION_V2_PROPOSED_NOT_ENABLED.md`.
- Этап 10: `RegistrationIdentityDAO` и проверка отсутствия PDA у бесплатного пользователя; семь серверных обработчиков KeyRotation проверяют статус. Платные могут исполнять старый процесс.
- Реальные тесты сквозного сервера/DB/сети по-прежнему не проведены. Патч только для test/dev review; **НЕ деплоить на production**.
- Отчёт: `PATCH_STAGES_8_9_10.md`.
## 23 октября 2026: накопительный патч с этапами 9 и 11–13
- **9:** шесть WS API с независимыми проверками имени и email. Утверждение владельца получено. JSON DTO, Registry и SPI в net-protocol, сервис в archive, startup в WsServer; ограничитель запросов по WebSocket и глобальный счётчик. Не проверено реальной Java Gradle-сборкой.
- **11:** переписана UI-регистрация под выбор paid/free namespace, Argon2id от полного логина, отдельный email, тест `1111`, Turbo ACK и текущую сессию. Существующая оплата Solana сохранена. Node-тесты проверяют кодеки/контракт, но не браузерное прохождение сценария.
- **12:** добавлен экран upgrade по неизменным ключам и внутренней подписи сертификата; status из сервера, fee из namespace-PDA. Не проверена отправка реальной транзакции localnet/devnet.
- **13:** добавлены контрактные тесты и smoke-runbook; полноценный E2E отложен до доступных Rust/Gradle/PostgreSQL/Turbo сетей.
- **Не готово:** `cargo`, full Gradle, PostgreSQL migration v33/v34, реальные WS, Turbo ACK, Solana localnet, браузер и межсерверный импорт. Все этапы **PARTIAL**, никакого production.
@@ -0,0 +1,720 @@
# SHiNE — МАСТЕР-ПЛАН РЕАЛИЗАЦИИ РЕГИСТРАЦИИ V2
**Дата:** 23 октября 2026 года
**Тип:** автономное техническое задание и инструкция для нового чата / Codex
**Базовый архив:** `SHiNE-bundle-2026.10.22-12.53.20(1).zip`
**Связанный предыдущий план:** `SHiNE_registration_roadmap_2026-10-23.md`
**Статус:** проектирование; изменения в исходный код этим документом НЕ внесены.
**Принцип:** один этап = один контролируемый патч. Не реализовывать весь документ за одну генерацию.
> **ВАЖНО ДЛЯ СЛЕДУЮЩЕГО ИСПОЛНИТЕЛЯ.** Не воспринимай этот документ как свидетельство, что код уже изменён. Сперва открой архив / рабочий репозиторий, прочитай локальные AGENTS.md, проверь текущую ветку и выполни только тот этап, который явно поручен. Все пути ниже сверены с архивом от 22.10.2026; в другой версии они могут отличаться. Если обнаружишь техническую неточность плана, исправь её обоснованно, сохранив согласованные продуктовые правила. Не менять API и формат существующего пользовательского блокчейна без предусмотренного проектом согласования.
---
## КАК ПЕРЕДАТЬ В НОВЫЙ ЧАТ (важнее всего)
Передать **оба вложения**:
1. Полный исходный архив проекта `SHiNE-bundle-2026.10.22-12.53.20(1).zip` либо актуальную версию репозитория.
2. **Этот файл мастер-плана V2**, а также последний журнал завершённых этапов, если работа уже начата.
В новом чате дать инструкцию:
> «Это проект SHiNE. Прочитай `SHiNE_registration_implementation_masterplan_v2_2026-10-23.md`, затем AGENTS.md в корне и в изменяемых модулях. Сначала сверь план с реальным исходным кодом. Выполни **только этап № N**, включая тесты, актуализацию обязательной документации и отчёт по шаблону из конца плана. Не придумывай другую схему регистрации. Не трогай production, не меняй публичный API/формат старого блокчейна без отдельного разрешения. После выполнения остановись».
Если кодовая база изменилась после архива, **источником истины для расположения кода является актуальный репозиторий**, а этот документ — источник согласованных требований и порядка действий.
---
# А. ПРОДУКТОВОЕ ТЗ: ЧТО ДОЛЖНО ПОЛУЧИТЬСЯ
## А1. Три допустимых состояния одного аккаунта
| Состояние | Кто удостоверяет имя | Пользовательский PDA Solana | Сервер доступа | Смена ключей |
|---|---|---|---|---|
| `PAID_DIRECT` | `shine_users` | есть | определяется своим PDA | разрешена по правилам PDA |
| `FREE_CERT` | сертификат регистратора в Arweave | нет | общий сервер из namespace-PDA | запрещена |
| `PAID_UPGRADED` | `shine_users` + ранее выданный сертификат | есть | определяется своим PDA | разрешена по правилам PDA |
`FREE_CERT → PAID_UPGRADED` **не создаёт нового пользователя**: полное имя `login@namespace`, root/client/blockchain публичные и приватные ключи, старые публикации, каналы и история блокчейна остаются прежними. Приватные ключи доступны только пользователю и не попадают на сервер.
**Уточнение по времени:** дата создания Solana PDA при upgrade может быть новой датой on-chain регистрации; дата первоначальной бесплатной регистрации и история Arweave остаются отдельно. Нельзя выдавать новую on-chain дату за дату создания исходного аккаунта или обнулять историю/расход лимитов.
## А2. Полные логины и пространства имён
- Каждый пользователь имеет имя `login@namespace` (пример: `alice@shine`, `bob@free`).
- Namespace — реально существующий аккаунт PDA программы `shine_users`, а не hardcoded список в UI.
- Тип `1`: прямая платная регистрация в Solana.
- Тип `2`: первоначальная бесплатная регистрация с сертификатом регистратора; позднее возможна платная регистрация PDA.
- Оба namespace имеют стоимость создания пользовательского PDA. Цена в типе `2` списывается **в момент перехода на Solana**.
- У каждого namespace есть нижняя граница длины части `login`; общая максимальная длина `login@namespace` на этом этапе — 30 байт при ASCII-алфавите.
- Не продавать отдельные короткие логины, не вводить premium-классы.
- Пространства создаются действующей **upgrade authority Solana-программы `shine_users`**, а не отдельной константой DAO. В будущем upgrade authority сможет принадлежать DAO.
- Пока разрешено **создавать**, но не редактировать или удалять namespace.
## А3. Ключи и пароль
- Клиент получает root key, blockchain key, client key из своего существующего механизма восстановления по **полному нормализованному логину и паролю**; не придумывать новый KDF.
- При регистрации бесплатного пользователя сервер видит **только три публичных ключа**.
- Приватный ключ **регистратора** — совершенно другой ключ. Пока находится в защищённой конфигурации сервера (вне Git); в будущем замещается аппаратным регистратором.
- Публичный ключ регистратора записывается в PDA бесплатного namespace.
- Нельзя связывать бесплатную регистрацию с хранением пароля или приватных ключей пользователя на сервере.
## А4. Сертификат и две подписи
Последовательность данных внутри подписанного ANS-104 DataItem:
1. Версия сертификата.
2. Полный `login@namespace`.
3. Три публичных ключа (порядок однозначно зафиксировать в протоколе; предлагается `root`, `blockchain`, `client`).
4. **Внутренняя Ed25519-подпись регистратора** только от полей идентичности — версии, полного имени и трёх публичных ключей (плюс протокольный domain separator).
5. SHA-256 от нормализованного email — **после внутренней подписи**, не входит в её сообщение.
6. Весь ANS-104 DataItem, включая поле хеша email и теги, подписывается **внешней подписью ANS-104 тем же ключом регистратора**.
Внутренняя подпись нужна для последующей проверки в Solana, внешняя — для удостоверения полного DataItem при его импорте. Это **две разные подписи от разных последовательностей байтов**.
Теги DataItem следует отделять от обычных пользовательских блоков, например существующим `App=test5592` плюс отдельный тег типа `t=reg`; точный набор тегов утвердить в документе протокола, не смешивать с `t=prof|conn|tech`.
## А5. Email
- При free-регистрации пользователь вводит email.
- Пока **проверка учебная**, реальная почта не отправляется; правильный код `1111` и это явно сказано в UI.
- В Arweave публикуется **только `SHA256(normalized_email)`**; исходный email не публикуется и не передаётся в Solana.
- Один нормализованный email-хеш должен соответствовать максимум одной бесплатной регистрации в известном реестре SHiNE.
- Пользователь понимает принятое ограничение: простой SHA-256 допускает проверку догадок об email; это не обещание полной анонимности.
- Пока единственный доверенный регистратор; не реализовывать сложную распределённую выдачу/резервирование и защиту от кражи ключа.
- Важная честная оговорка: `1111` доказывает только ввод фиксированного кода, **не подтверждает владение email**. Глобальная уникальность зависит от полноты синхронизации и единственного регистратора; не объявлять это криптографически абсолютной гарантией.
## А6. Источники идентичности и приоритет
- Для платных пользователей источником полномочий служит настоящий Solana PDA.
- Для бесплатных — проверенный сертификат Arweave, связанный с PDA бесплатного namespace.
- После upgrade статус меняется **у существующей логической личности**; Arweave-сертификат сохраняется как историческое основание исходной выдачи имени.
- При импорте сертификата всегда проверяется полномочие подписавшего ключа; сам факт хранения в Arweave не делает запись доверенной.
- Если запись уже принята, произвольная другая запись того же логина **не должна её заменять**. Дополнительную модель кражи ключа пока не строить.
## А7. Сервер доступа и ограничения free
- До Solana upgrade сервер доступа всех аккаунтов бесплатного namespace задаёт его namespace-PDA.
- Для платного пользователя сервер доступа берётся из собственного PDA v1.2.
- `FREE_CERT` не может менять root, blockchain и client keys; не может менять сервер доступа; не может запускать fork/key rotation, если это меняет ключи.
- Ограничение действует не только в UI, но и в серверных проверках; обязательно найти альтернативные пути соответствующих операций.
- Публикации, каналы, связи, личные сообщения и чтение истории должны работать обычным образом.
- После upgrade смена ключей/сервера работает по существующим правилам Solana.
## А8. Экономика и управление
- `init_users_economy_config` остаётся доступной любому подписанту; она инициализирует детерминированные исходные параметры только один раз.
- `update_users_economy_config` вместо постоянной `DAO_AUTHORITY` проверяет **действующую upgrade authority через ProgramData**.
- Стоимость **регистрации** — из соответствующего namespace-PDA; стоимость покупки дополнительных лимитов и иные параметры остаются в economy-PDA.
- При `create_namespace` и каждой новой регистрации economy-PDA присутствует в account metas как read-only для текущего механизма history/poll синхронизации.
- Чтение economy-PDA не обязано генерировать WebSocket account-change notification; для истории продолжает работать `getSignaturesForAddress`/периодический poll.
- Удалить использование promo_seller и shine_login_guard из **новой пользовательской регистрации**, связанные инструкционные ветки `shine_users`, клиентские поля промокодов и premium-проверки. Отдельные legacy-программы без необходимости не удалять.
## А9. Мгновенный вход после Turbo
`код 1111 → выпуск подписанного DataItem → успешный ACK Turbo → импорт тех же raw signed bytes локально → пользователь получает доступ`.
- **Не ждать** высоты блока Arweave для первого входа.
- Другие серверы обнаружат запись позже через Arweave, и это нормально.
- Локально различать `TURBO_ACCEPTED` и `ARWEAVE_CONFIRMED`; не путать приём Turbo с окончательным подтверждением сети.
- При сетевой ошибке или неизвестном результате публикации не терять пользовательские ключи, не создавать бессмысленно новый сертификат и новый DataItem при каждом повторе.
## А10. Не входит в этот релиз
Нет реального SMTP, восстановления ключей через email, изменения/удаления namespace, аппаратного регистратора, мультиподписей регистраторов, обработки компрометации его ключа, управления DAO, продажи премиальных имён, автоматической миграции старых Solana PDA/логинов, масштабного редизайна остальных экранов.
---
# Б. КАРТА РЕАЛЬНОГО ИСХОДНОГО КОДА (архив 22.10.2026)
Эти файлы **существуют** в проверенном архиве. Для новых классов ниже будет явно сказано «создать».
| Компонент | Существующие точки входа | Что там сейчас / зачем менять |
|---|---|---|
| Solana | `shine-solana/shine/programs/shine_users/src/lib.rs` | instruction dispatcher, `create_user_pda`, `update_user_pda`, Ed25519 precompile, экономика, promo и guard |
| Настройки Solana | `shine-solana/shine/programs/shine_users/src/settings.rs` | `USER_PDA_SEED_PREFIX="user_login="`, старые константы `DAO_AUTHORITY`, guard, promo |
| Документ Solana | `shine-solana/shine/doc/programs/shine_users.md` | контракт, аккаунты, инструкции |
| Документ PDA v1.2 | `shine-solana/shine/doc/formats/shine-user-pda-format-v.1.2.md` | существующий формат полноценного PDA; сохранять |
| Solana UI codec | `shine-UI/js/services/shine-user-pda-service.js` | seed, сериализация, транзакции регистрации, promo |
| Solana UI facade | `shine-UI/js/services/solana-register-service.js` | guard/premium precheck, доступность имени, вызов общего сервиса |
| Адреса программ | `shine-UI/js/solana-programs.js` | реальные program id считывать из актуального окружения |
| Получение ключей | `shine-UI/js/services/auth-service.js` | `derivePasswordKeyBundle(login,password)`; полный login входит в Argon2id/KDF |
| Регистрация UI | `shine-UI/js/pages/register-view.js`, `registration-payment-view.js`, `registration-draft-keys-view.js` | старая платная форма, лимиты длины и promo UI |
| Логин / настройки | `shine-UI/js/pages/login-view.js`, `login-password-view.js`, `settings-view.js`, `key-rotation-view.js` | вход и функции ключей |
| UI router/state | `shine-UI/js/router.js`, `shine-UI/js/state.js` | новые страницы и черновики регистрации |
| Solana sync | `SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/service/SolanaUsersSyncService.java` | историю отслеживает по economy-PDA; snapshot и checkpoint |
| Solana parser | `.../sync/codec/ShineUsersCodec.java` | декодирование инструкций и записей |
| Solana PDA utility | `.../sync/util/SolanaPdaUtil.java` | вычисляет findProgramAddress на Java |
| Solana sync DB | `.../sync/storage/postgres/PostgresStorageRepository.java` | upsert/account snapshot; нужны namespaces и новые статусы |
| База | `SHiNE-server/shine-server-db/src/main/resources/postgres/schema_v1.sql` и `migration_v31.sql`, `migration_v32.sql` | baseline и текущие миграции; следующая — новая по порядку, НЕ переписывать прошлые |
| DB login facade | `SHiNE-server/shine-server-db/src/main/java/shine/db/sql/CurrentUsersSql.java` | сейчас возвращает пользователей только из `solana_user_pda_current` |
| DB DAO | `.../shine/db/dao/CurrentUsersDAO.java`, `SolanaUserPdaCurrentDAO.java`, `UserAccessServersCurrentDAO.java` | проверки пользователей, ключей, сервера |
| Авторизация | `SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/` | `SolanaUserPdaImportService`, `Net_ResolveLoginForAuth_Handler`, `Net_CreateAuthSession__Handler` и связанные классы |
| Ротация | `.../handlers/keyRotation/`, `KeyRotationSessionsDAO.java` | запреты для `FREE_CERT` |
| Config | `SHiNE-server/shine-server-config/src/main/java/utils/config/AppConfig.java` | встраивание параметров регистратора без Git-секрета |
| ANS-104 | `SHiNE-server/shine-server-blockchain/src/main/java/blockchain/Ans104DataItem.java` | сериализация, deep-hash, Ed25519 signature verify |
| Turbo | `SHiNE-server/shine-server-archive/src/main/java/server/archive/TurboDataItemUploader.java` | принимает **уже подписанный** DataItem, проверяет и отправляет |
| Arweave import | `SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncService.java` | GraphQL discovery, блоки, фильтр `block.height`; нужен отдельный путь регистрации |
| API dispatch | `SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/JsonHandlerRegistry.java` | подключение новых WS операций |
| Документация API | `docs/API/01_User_Registration_API.md`, `docs/API/09_Operations_Index.md` | новые операции и ошибки: согласовать изменения |
| Документация sync | `docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md`, `deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md` | алгоритм и эксплуатация sync |
| Деплой | `deploy/AGENTS.md`, `deploy/TEST_SERVERS.md`, `docs/Инициализация_Solana_регистрации/README.md` | тестовый контур и порядок инициализации |
**Подтверждённые особенности кода:**
- В `shine_users` opcode 1 = init economy, 2 = update economy, 3 = create user, 4 = update user, 5 = upsert promo seller, 6 = close legacy. Новым инструкциям назначать непересекающиеся id, зафиксировать их в документации.
- Текущее `create_user_pda` подтверждает root и blockchain через Ed25519 instructions sysvar (разбор относительно текущей инструкции). Дополнительная подпись регистратора потребует тщательно задать расположение этих инструкций.
- Пользовательский PDA v1.2 содержит root, client, forks blockchain key, access servers, а не простую запись «три ключа + имя».
- `solana_user_pda_current` сейчас является центральной таблицей и целью внешних ключей; **нельзя** подделывать наличие on-chain PDA для free.
- В `CurrentUsersSql.usersSubquery` список сейчас берётся только из `solana_user_pda_current`.
- `TurboDataItemUploader.upload` не подписывает DataItem за клиента: raw signed DataItem нужно сформировать до вызова.
- В `ArweaveBlockSyncService` текущая основная выборка пропускает GraphQL-записи без `block.height`; free-registration требует отдельной ветки и немедленного локального пути.
- В `register-view.js` есть временная логика нормализации `<=20` и пропуск `_` для guard. Для новой системы `_` не удалять из идентичности: `a_b` и `ab` не должны внезапно стать одним именем.
**Читать перед началом:** корневой `AGENTS.md`, `COMMIT_AND_VERSION_RULES.md` и локальные `shine-solana/shine/AGENTS.md`, `SHiNE-server/AGENTS.md`, `shine-UI/AGENTS.md` при работе с соответствующими модулями. Особенно: проект требует отдельного согласования перед **изменением публичного WebSocket API** или **формата существующего блокчейна**. Утверждённая архитектура не отменяет эти рабочие правила.
---
# В. ПРОТОКОЛ V1: ПРЕДЛАГАЕМАЯ ТОЧНАЯ КОНКРЕТИЗАЦИЯ
**Статус подраздела В:** проект формата для принятия на этапе 1. Дальше его нельзя «чуть изменить в одном месте»; изменение только одновременно в Rust, JS, Java, документах, фикстурах. Здесь изложены технические детали уже согласованного поведения, не новые продуктовые возможности.
## В1. Канонический login
- `localPart` и `namespace` — ASCII lowercase, разрешённые символы утвердить по совместимости с кодом; практичный набор: `[a-z0-9_]`, без пробелов, без второго `@`.
- Полное имя: `${localPart}@${namespace}`.
- `normalizedFullLogin` — байты UTF-8 ровно этой lowercase-строки, без пробелов по краям. Для проверки нового аккаунта отклонять неоднозначные формы, не преобразовывать «почти такие же» имена молча.
- Общее ограничение полного имени: 30 **UTF-8 байт** на этой версии; минимальная длина localPart — из namespace PDA, считать байты (ASCII = символы).
- Никогда не отбрасывать `_`, не обрезать строку, не менять namespace после создания.
## В2. Seed пользовательского PDA
```text
preimage = UTF8("user_login=" + normalizedFullLogin)
seed32 = SHA256(preimage) // именно 32 СЫРЫХ БАЙТА
userPda = findProgramAddress([seed32], shineUsersProgramId)
```
**Не** base58-строку хеша, не hex-строку, не два старых seed. На адрес дополнительно влияет programId и bump стандартного findProgramAddress. Для подписания `create_program_address` программа использует `[seed32, bump]`.
## В3. Seed namespace PDA
```text
preimage = UTF8("namespace=" + normalizedNamespace)
seed32 = SHA256(preimage)
namespacePda = findProgramAddress([seed32], shineUsersProgramId)
```
Префикс `namespace=` здесь предложен как **окончательная константа v1 после утверждения на этапе 1**; его нельзя менять после первых созданных PDA.
## В4. Бинарный namespace-PDA
```text
major u8 // 1
minor u8 // 0
namespace_type u8 // 1 paid-direct / 2 free-cert
min_localpart_len u8
namespace_len u8 // N
namespace u8[N] // lowercase ASCII
registration_fee u64 LE // lamports; и для будущего upgrade free
if namespace_type == 2:
registrar_pubkey u8[32] // Ed25519
server_login_len u8 // M
server_login u8[M] // полный login@namespace зарегистрированного сервера
```
Сериализатор и парсер должны отвергать неизвестные версии/типы, неправильную длину данных, некорректный namespace и подставленный PDA. Если Solana-аккаунт создаётся с дополнительной областью из-за выравнивания/rent, определить однозначную политику padding и её проверку. Для type 1 поля регистратора/сервера отсутствуют, а не заполнены «нулевой фикцией».
## В5. Внутренняя подпись бесплатного сертификата
Пример детерминированного массива байтов (предлагается как v1):
```text
identity_fields =
major:u8 (=1) || minor:u8 (=0) ||
full_login_len:u8 || full_login_utf8 ||
root_pubkey:32 || blockchain_pubkey:32 || client_pubkey:32
inner_message = UTF8("SHiNE_FREE_REG_V1\u0000") || identity_fields
inner_signature64 = Ed25519.sign(registrar_private_key, inner_message)
```
- Domain separator убирает риск приравнивания подписи к подписи чужого протокола.
- Контракт должен проверить **байты** `inner_message`, а не локальный JSON/строковую интерпретацию.
- Внешняя ANS-104 подпись использует стандартный `deepHash(...)` и **не заменяет** внутреннюю подпись.
- Тот же публичный ключ регистратора должен быть в namespace PDA и в owner внешнего DataItem.
## В6. Payload DataItem
```text
payload = identity_fields || inner_signature64:64 || normalized_email_sha256:32
```
Плюс теги, отделяющие регистрационный DataItem от пользовательского блока. Email внутри `inner_message` отсутствует **осознанно**, по решению владельца проекта.
**Не включать:** пароль, masterSecret, root/blockchain/client private keys, приватный ключ регистратора, исходный email.
## В7. Нормализация email
- `trim` пробелы с краёв.
- Unicode NFC, lowercase без зависимости от локали.
- Не удалять `+tag` и точки: разные почтовые сервисы трактуют их неодинаково.
- `email_hash = SHA256(UTF8(normalizedEmail))`.
- Хеш проверяется по индексу, а не принимается на веру со слов клиента: пока сервер получает email по защищённому каналу, нормализует сам.
## В8. On-chain Ed25519-инструкции и экономическая транзакция
Упорядочить инструкции в Solana-транзакции так, чтобы контракт надёжно проверял (а) подпись root над хешем записи пользователя, (б) подпись blockchain над тем же хешем и (в) для type 2 подпись регистратора над `inner_message`. Количество/индексы Ed25519 IX и номера инструкций должны быть зафиксированы в документах **и тестах на отрицательные случаи**. Не делать проверку «подпись где-то есть в транзакции» без проверки конкретного сообщения, ключа и содержания.
Регистрационную комиссию переводить в существующий `shine_payments` inflow-vault с сохранением текущего расчёта дополнительного лимита. Считывать цену регистрации из namespace, не из economy. Economy PDA участвует read-only и используется для параметров лимитов и истории транзакций.
---
# Г. ВЫПОЛНЕНИЕ: 14 ПОСЛЕДОВАТЕЛЬНЫХ ЭТАПОВ
Каждый этап начинается с аудита указанных файлов, завершается **сборкой, целевыми тестами, документацией и отчётом**. Завершение одного этапа не равно завершению всего проекта.
## ЭТАП 0. Подготовить ветку, матрицу зависимостей и базовый тестовый стенд
**Зачем:** зафиксировать исходное состояние и не выполнять изменения вслепую.
**Файлы/места:** корень, все `AGENTS.md`, `COMMIT_AND_VERSION_RULES.md`, `deploy/TEST_SERVERS.md`, `shine-solana/shine/`, `SHiNE-server/`, `shine-UI/`.
**Действия:**
1. Распаковать/клонировать исходник. Зафиксировать commit/архив, рабочую ветку, версии tools, Rust/Anchor/Solana, Java/Gradle, Node, PostgreSQL.
2. Прочитать инструкции по модулям. Разрешения на production **не подразумеваются**.
3. Установить базовые команды сборки/тестов по реальным файлам проекта; выполнить smoke baseline и записать результаты (включая уже существующие ошибки).
4. Найти все вызовы `find_user_pda`, `user_login=`, `getProgramAccounts`, константы 20/8, `shine_login_guard`, `promo_seller`, `registration_fee_lamports`, `solana_user_pda_current`, `resolveLogin`.
5. Выписать все SQL FK на `solana_user_pda_current`, PostgreSQL triggers/views и клиентов `CurrentUsersSql`; отдельным списком — операции, зависящие от real Solana PDA.
6. Создать в ветке `docs/registration-v2/IMPLEMENTATION_STATUS.md` (или отдельный рабочий журнал), заполнять после каждого этапа.
**Готово, когда:** известны реальные точки редактирования, baseline сборки и правила релиза; основной код пока неизменён.
## ЭТАП 1. Зафиксировать протоколы и тест-векторы Rust/Java/JS
**Зависимость:** этап 0.
**Создать/изменить:**
- `shine-solana/shine/doc/formats/shine-namespace-pda-format-v1.md` (новый).
- `docs/Протоколы/SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md` (новый).
- `shine-solana/shine/doc/programs/shine_users.md` (разделы новых IX и seed).
- Общие тестовые фикстуры по одному логину/ключам/email; место выбрать так, чтобы тесты трёх языков могли читать их.
**Задачи:**
1. Застолбить все поля форматов, версии, число байт, encoding `u64 LE`, `full login`, запрет неоднозначных имён.
2. Застолбить доменные префиксы seed и внутренней подписи.
3. Зафиксировать структуру подписанного `inner_message` и `ANS-104 payload`, уникальные теги для регистраций.
4. Фиксировать максимумы, ошибка/результат на некорректном типе, парсинге, padding, цене, серверном логине.
5. Подготовить тест-векторы: `alice@shine`, `bob@free`, `_` в имени, минимальная длина, 30-й байт, 31-й байт; один детерминированный email.
6. Записать ожидаемые хеши и PDA **для конкретного program ID теста**. Проверка в Rust/Java/JS обязана давать побайтово одинаковые значения.
7. Зафиксировать как обрабатывается созданная ранее история free пользователя: ключи/блоки неизменны; создание Solana PDA может иметь новую timestamp без сброса логической регистрации.
**Тесты:** round-trip кодирования; одинаковые хеши; подмена одного ключа ломает внутреннюю подпись; подмена email ломает внешнюю ANS-104 подпись.
**Готово, когда:** ни исполнитель Solana, ни исполнитель UI не должен выбирать форматы заново.
## ЭТАП 2. Solana: Namespace PDA и полномочия upgrade authority
**Зависимость:** этап 1.
**Изменить:**
- `shine-solana/shine/programs/shine_users/src/lib.rs`;
- `.../settings.rs`;
- `shine-solana/shine/tests/shine.ts` и документацию программы.
**Задачи:**
1. Добавить типы `NamespaceState`/`CreateNamespaceArgs`, строгий parser/serializer.
2. Добавить **новый opcode** `IX_CREATE_NAMESPACE` без конфликта с текущими 1–6.
3. Проверять правильный PDA из SHA-256 seed `namespace=...`, owner, rent, размер, неповторяемость имени.
4. Проверять владельца `ProgramData`: это ProgramData **конкретной** программы, принадлежащий BPF upgradeable loader, с текущей `upgrade_authority_address`; signer должен совпадать. Если программа immutable — отказ.
5. В `update_users_economy_config` применить ту же проверку ProgramData. Инициализацию economy не менять.
6. В `create_namespace` принять economy-PDA как read-only account meta; проверить его ожидаемый адрес. Цена хранится в namespace.
7. Сделать CLI/скрипт подготовки создания двух test namespaces и независимый декодер.
**Тесты:** админ создаёт; посторонний не создаёт; чужой/поддельный ProgramData не помогает; тот же namespace повторно отвергается; неверный type/version/данные отвергаются; economy init всё ещё открыт, economy update закрыт.
**Готово, когда:** два test namespace создаются и читаются в localnet/devnet; **пока не изменять production**.
## ЭТАП 3. Solana: создание PDA пользователем напрямую и по сертификату
**Зависимость:** этап 2.
**Изменить:** `shine_users/src/lib.rs`, `settings.rs`, `shine/tests/shine.ts`, документы формата PDA v1.2 и программы.
**Задачи:**
1. Во всех местах create/update/close (где нужно) заменить вычисление пользовательского PDA на SHA-256 от **полного** имени, включая `@namespace`.
2. Проверять `(localPart, namespace)`, тип, min local length, max full length 30 байт, правильный namespace-PDA.
3. Оставить бинарный payload существующего PDA пользователя **версии 1.2**, если нет объективной необходимости его менять.
4. Для type 1: проверка доступности имени, root/blockchain подтверждение, создание PDA, комиссия по namespace + лимит из economy.
5. Для type 2: дополнительно требовать внутреннюю подпись регистрирующего ключа над тем же полным именем и **теми же** root/blockchain/client public keys. Ключ проверки брать из on-chain namespace.
6. Передать economy-PDA в account list read-only при любой регистрации; сохранить `shine_payments` inflow-vault.
7. Обновить Ed25519 instruction index: корректно отличать root, blockchain, registrar; отрицательные тесты на путаницу индексов.
8. Удалить из новой регистрации guard CPI, premium-classification, promo seller args/promo IX и связанные комиссии. Старые отдельные Solana-программы не трогать без причины.
9. Для upgrade не допускать повторного Solana PDA, не требовать создания заново пользовательского Arweave блокчейна.
10. Продумать состояние лимитов: бесплатный пользователь мог уже писать и тратить стартовый ресурс — не объявлять оплаченный лимит или баланс «с нуля» без согласования с реальным текущим учётом блоков. Не давать дополнительных стартовых бонусов за сам факт upgrade без явного правила.
**Тесты:** прямой paid create; free→paid create; цена для разных namespaces; заблокирован type2 без сертификата; неверный регистратор; изменённый client/root/blockchain; чужой namespace; 30 vs 31 байт; повторное создание; корректность PDA; существующий paid update без регрессии.
**Готово, когда:** новая Solana-программа умеет создавать обе категории PDA и корректно обновлять существующую v1.2 запись. UI можно внедрять позже.
## ЭТАП 4. Клиентский Solana codec, поиск PDA и bootstrap namespace
**Зависимость:** этап 3.
**Изменить:**
- `shine-UI/js/services/shine-user-pda-service.js`;
- `shine-UI/js/services/solana-register-service.js`;
- `shine-UI/js/solana-programs.js` при необходимости;
- `shine-UI/server-ui/` (если инструменты управления серверным аккаунтом используют прежний seed).
**Задачи:**
1. Добавить JS encode/decode NamespaceState, `deriveNamespacePda()` и `deriveUserPda(fullLogin)`.
2. Удалить `getProgramAccounts`/поиск по старой строке-логину или адаптировать под хеш seed и новый формат. Не предполагать, что seed можно восстановить из PDA без данных.
3. Переделать сериализацию `create_user_pda`, account metas (namespace, economy), fee display, IX order.
4. Для type2 сформировать и подключить Ed25519 ix с **готовой** внутренней подписью сертификата; приватный ключ регистратора в браузер не попадает.
5. Убрать UI service API `promoCode` и premium guard precheck там, где они обслуживают регистрацию.
6. Обновить код **создания серверного аккаунта**, который тоже является user PDA и тоже требует полный `login@namespace`.
7. Создать независимые JS unit tests на PDA, namespace decode, transaction serialization, equality signature message.
**Готово, когда:** тестовый JS может создать correct paid/free Solana transaction по контракту без рабочего пользовательского экрана.
## ЭТАП 5. PostgreSQL: единый логический пользователь вместо фиктивного free PDA
**Зависимость:** этап 1; желательно готов этап 3 для схемы Solana полей.
**Изменить:** schema/migrations `SHiNE-server/shine-server-db/src/main/resources/postgres/`; `CurrentUsersSql`, `CurrentUsersDAO`, `SolanaUserPdaCurrentDAO`, `UserAccessServersCurrentDAO`, зависимые views/triggers/DAO, отдельные entities.
**Главный риск:** **текущие FK, stats и queries считают `solana_user_pda_current` полным списком пользователей.** Нельзя просто положить сертификаты в новую таблицу и надеяться, что всё заработает.
**Предпочтительное решение:** создать каноническую таблицу **логических пользователей**, например `user_identity_current` (название финализировать по реальному SQL), с уникальным `normalized_login` и ключами; оставить `solana_user_pda_current` таблицей **только настоящих** PDA, связанной с логической личностью. Хранить `namespace`, `registration_source`, `registration_status`, `registered_at_ms`, `free_data_item_id`, `solana_pda_address (nullable)` и текущие ключи. В свободном состоянии `solana_pda_address = NULL`, не выдумывать адрес «как будто on-chain аккаунт есть».
**Задачи:**
1. На основе полного поиска SQL составить список всех FK/views/triggers/запросов и миграционный граф.
2. Создать новую **следующую** миграцию после существующей v32 (номер брать из актуального исходника, если новее). Не переписывать исторические миграции.
3. Добавить таблицу синхронизированных namespaces, таблицу сертификатов (полный signed payload/ID/hash email/внутренняя подпись/публикационный статус) и индексы уникальности.
4. Сформировать общий индекс `user_identity_current`, связать paid/free; изменить зависимости SQL на него там, где нужна любая идентичность, а не именно реальный PDA.
5. Обновить `CurrentUsersSql.usersSubquery()` и соответствующие DAO на общее представление пользователя. В частях, где необходим фактический PDA (rotation, Solana-specific reads), делать явную проверку `has_solana_pda`.
6. Учитывать сервер доступа: `FREE_CERT` → namespace.defaultServerLogin; `PAID_DIRECT`/`PAID_UPGRADED` → account access servers из PDA.
7. Добавить атомарную операцию **upgrade существующего логического аккаунта** без дублирования `login`, ссылок, каналов и связей.
8. Для уже существующих реальных PDA подготовить idempotent backfill в канонический индекс; старая база не должна разрушаться.
9. Добавить интеграционные тесты на restart/re-run migration; FK, статистику, связи, access routing, уникальность.
**Готово, когда:** тот же логин может существовать как `FREE_CERT` без PDA и затем приобрести настоящий PDA без новой строки логического пользователя. На чистой и обновляемой тестовой базе старые DAO продолжают работать.
## ЭТАП 6. Java синхронизация Solana: namespaces + новые PDA + события
**Зависимость:** этапы 3 и 5.
**Изменить:**
- `SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/service/SolanaUsersSyncService.java`;
- `.../sync/codec/ShineUsersCodec.java`;
- `.../sync/storage/postgres/PostgresStorageRepository.java`;
- `.../sync/util/SolanaPdaUtil.java`;
- `docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md`;
- `deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md`.
**Задачи:**
1. Кодеки namespace PDA, новой инструкции и нового расчёта seed.
2. History parse: `IX_CREATE_NAMESPACE`, новый `IX_CREATE_USER_PDA` и существующие update. Сохранять `economy PDA` как индекс RPC истории.
3. Snapshot bootstrap должен находить **все актуальные namespace** и **все реальные пользовательские PDA**, а не зависеть только от уже обработанных событий.
4. На каждое подтверждённое создание/обновление делать идемпотентный upsert в реестр, не изменять кэш бесплатного сертификата без проверок.
5. Если пришёл paid upgrade для существующего free логина — обновить ту же логическую личность, а не удалить/recreate.
6. Реализовать корректный checkpoint/retry при RPC timeout, ошибках декодера, дубликатах signature, задержках сети.
7. Сохранять доступ к деталям economy после init/update для прежней модели лимитов.
8. Проверить, что сервер умеет различать `free cert есть`, `Solana PDA ещё нет` и `Solana PDA уже появился`.
**Готово, когда:** из clean snapshot и из history replay получается одна и та же PostgreSQL-сущность для пользователей и namespaces; upgrade не плодит дубли.
## ЭТАП 7. Сервер: доверенный регистратор (временная программная заглушка)
**Зависимость:** этапы 1, 5 и импорт namespace из 6.
**Изменить/создать:** `SHiNE-server/shine-server-config/src/main/java/utils/config/AppConfig.java`; новый сервис/интерфейс registrar в подходящем Java модуле; unit tests; новый конфигурационный README.
**Задачи:**
1. Настройки: включено ли бесплатное регистрирование, какие namespace обслуживает сервер, публичный ключ и **путь/secret reference** к приватному ключу регистратора; не хранить ключ в Git или логе.
2. При старте сверять локальный public key с public key **соответствующего** on-chain namespace; при несоответствии блокировать новые выдачи, не ломая работу старых пользователей.
3. Выделить интерфейс `RegistrarSigner.sign(byte[])` и software-реализацию. В будущем можно заменить на hardware signer.
4. Подготовить детерминированный `identity_fields` и `inner_message`; получить внутреннюю Ed25519-подпись.
5. Собрать `payload` и внешнюю ANS-104 подпись тем же keypair; задать отличающиеся от user block теги.
6. Проверять формат имени, min/max длины, неповторяемость известных login/email, тестовый код `1111` и соответствие namespace type2.
7. Не принимать приватные ключи пользователя даже «временно», не хранить пароли.
8. Не вводить сейчас аппаратное устройство и сложный распределённый mutex/компрометацию ключа; достаточно корректного последовательного выполнения обычной выдачи на одном регистраторе.
**Тесты:** повторяемые фикстуры; правильная внутренняя + внешняя подпись; неверный namespace; отсутствие ключа; несоответствие pubkey; неправильный email code; секреты не появляются в диагностике.
**Готово, когда:** Java локально выдаёт raw signed ANS-104 bytes с обеими проверяемыми подписями без Turbo и UI.
## ЭТАП 8. Arweave: отдельный импорт сертификатов и немедленное принятие после Turbo
**Зависимость:** этапы 5, 6 и 7.
**Изменить:** `SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncService.java`, `TurboDataItemUploader.java` **переиспользовать**, `Ans104DataItem.java` **переиспользовать**; новая ветка/сервис регистрации и DAO. Не менять формат существующих обычных блоков.
**Задачи:**
1. Создать **отдельный importer** для `t=reg` DataItem, а не подделывать пользовательский блок.
2. Парсер payload; проверка внешней ANS104 подписи, owner = on-chain registrar pubkey, внутренней Ed25519 подписи, имени, namespace, структурных границ.
3. Проверить уникальность ID DataItem; не дать повторному discovery создать двойника или переписать существующий login.
4. После успешного Turbo upload сразу прогонять **точно те же raw signed bytes** через этот importer в локальную БД.
5. Обновить GraphQL discovery / типовые фильтры, чтобы независимый сервер мог получить `t=reg` и восстановить сертификаты позже. Не ограничиваться существующим фильтром только блоков/высот без учёта регистраций.
6. Хранить `TURBO_ACCEPTED`, последующее подтверждение Arweave, отметки retries, ID и ошибку при необходимости.
7. Idempotent import: immediate → GraphQL повторный импорт должен дать «уже учтено» и сохранить те же ключи/identity.
8. При Turbo timeout/неопределённости не выдавать ложный окончательный успех; предусмотреть проверку известного DataItem ID и повторную отправку идентичных байтов.
9. Сервер B импортирует записи, созданные сервером A, при достижении Arweave и наличии namespace registry.
**Готово, когда:** подтверждение Turbo даёт первый вход на принимающем сервере без ожидания GraphQL; второй сервер узнаёт пользователя после sync; дубли harmless.
## ЭТАП 9. Сервер: WS/API операции бесплатной регистрации
**Зависимость:** этапы 7 и 8.
**До изменения API:** прочитать `AGENTS.md`, `docs/API/*` и **получить отдельное согласование пользователя на конкретные новые операции/поля** — это правило репозитория, даже когда общая функциональность одобрена.
**Изменить:** `JsonHandlerRegistry.java`, новые handler/DTO классы в `shine-server-net-protocol`, `docs/API/01_User_Registration_API.md`, `docs/API/09_Operations_Index.md`.
**Предложение минимального протокола (ИМЕНА ОПЕРАЦИЙ — ПРОЕКТ, не существующий код):**
| Операция | Ввод | Результат |
|---|---|---|
| `GetNamespaces` | — | список существующих namespace + type/fee/min/server |
| `CheckRegistrationAvailability` | fullLogin, email (для free) | доступен ли login/email; не считать результат резервированием |
| `StartFreeRegistration` | fullLogin, 3 public keys, email | продолжение проверки кода, id временного процесса при необходимости |
| `ConfirmFreeRegistration` | id/данные процесса, code=`1111` | Turbo dataItemId, статус, подтверждённый fullLogin |
| `GetRegistrationStatus` | login или ID операции | `FREE_CERT`, `PAID_DIRECT`, `PAID_UPGRADED`, `PENDING`, ошибка |
**Задачи:**
1. Выбрать окончательные `op` имена по текущему стилю API, чтобы не ломать существующий клиент.
2. Согласовать поля/ответы/ошибки, зафиксировать в `docs/API/` **до редактирования реализации**.
3. Интегрировать `RegistrarSigner`, Turbo uploader, импортёр и logical identity DAO.
4. Не помещать приватные пользовательские ключи в requests/responses. Не отдавать приватный registrar key.
5. Любую выдачу завершать только после валидного signed DataItem и успешного локального импорта.
6. Возвращать явный статус `Turbo accepted, chain confirmation pending` без обещания финального подтверждения.
7. Сделать обработку ошибочного/отменённого запроса, потерянного ответа и retry.
8. Добавить unit/integration tests handler и документированные errors.
**Готово, когда:** WS-клиент может пройти free-регистрацию и получить подтверждённую локальную идентичность без UI.
## ЭТАП 10. Сервер: единая авторизация и реальные ограничения `FREE_CERT`
**Зависимость:** этапы 5, 8, 9.
**Изменить:** `.../handlers/auth/{SolanaUserPdaImportService,Net_ResolveLoginForAuth_Handler,Net_CreateAuthSession__Handler}` и соседние обработчики, `CurrentUsersDAO`, `UserAccessServersCurrentDAO`, `.../handlers/keyRotation/`, соответствующие docs/API.
**Задачи:**
1. Определить единый объект `ResolvedIdentity`: fullLogin, root/client/blockchain public keys, source, status, namespace, accessServer, hasSolanaPda.
2. Разрешить login как через PDA, так и через сертификат; обе ветки выдают общую структуру авторизации, но не одинаковые права.
3. Проверять пароль локально через получение ключей, а серверу предоставлять существующие криптографические proofs; сервер не получает пароль или приватные ключи.
4. До upgrade routing `FREE_CERT` берёт сервер из namespace. После upgrade — из пользовательского PDA.
5. Закрыть все варианты server-side смены ключей, access server и fork rotation для free (искать как прямые обработчики, так и фоновые сервисы/обходные API).
6. Убедиться, что бесплатные могут создавать подписанные блоки, читать/писать в каналах и работать с direct messages как обычные пользователи.
7. Не использовать «наличие строки в solana_user_pda_current» как единственный признак существования человека в общих обработчиках.
8. При upgrade переключать источник полномочий без потери session, graph, messages, user profile, saved files.
**Готово, когда:** free/paid login и работа с контентом функционируют; попытки обойти ограничения free отвергаются именно сервером.
## ЭТАП 11. UI: выбор типа регистрации, формы и мгновенный вход
**Зависимость:** этапы 4, 9 и 10.
**Изменить:** `shine-UI/js/pages/{register-view,registration-payment-view,registration-draft-keys-view,login-view,settings-view,key-rotation-view}.js`, `js/state.js`, `js/router.js`, `js/services/solana-register-service.js`. При необходимости создать `registration-method-view.js`, `registration-email-view.js` и собственный контролируемый onboarding step.
**Задачи:**
1. Первый экран: «Через Solana» или «Бесплатно»; UI не диктует namespace из захардкоженных названий.
2. Drop-down подгружает on-chain namespace list, показывает fee/min/type и разрешает выбирать соответствующие способу регистрации.
3. Пользователь вводит localPart и видит `localPart@namespace`; длина проверяется включая суффикс. Старые 20/8 и premium/promo form logic отключить в новой ветке.
4. Локальная генерация keyBundle из **полного имени и пароля**, одинаковая для free/direct paid/последующего входа.
5. Бесплатный flow: public keys + email → экран с текстом «Тест: код 1111; письмо не отправляется» → server-confirm → Turbo ACK → локальный sign-in.
6. Любая ошибка Turbo/сети **не должна заставлять генерировать новые ключи** или терять корректно введённый логин/пароль до понятного завершения процесса; обеспечить осознанную очистку чувствительного UI state.
7. Платный flow использует новую транзакцию, цену namespace и текущую существующую оплату.
8. У free отображается статус, фиксированный access server, ограничения ключей и будущая кнопка перехода в Solana.
9. Сохранить текущую архитектуру UI из `shine-UI/AGENTS.md`: App/Router единственный mount owner, shared components, никакого нового UI-framework.
10. Обновить FAQ, подсказки и ошибки; не обещать, что Arweave окончательно подтвердил запись при одном Turbo ACK.
**Готово, когда:** новый человек может пройти paid или free регистрацию и войти с обычного экрана без ручных CLI/WS команд.
## ЭТАП 12. Upgrade UI и end-to-end free → Solana без смены личности
**Зависимость:** этапы 3, 4, 6, 10, 11.
**Изменить:** `shine-UI/js/services/shine-user-pda-service.js`, `shine-UI/js/pages/settings-view.js` (или отдельная `registration-upgrade-view.js`), серверный статус identity при Solana sync.
**Задачи:**
1. Кнопка «Зарегистрировать аккаунт в Solana» видна только `FREE_CERT`.
2. Показать **сумму из namespace type2**, получаемую из Solana, а не старую цену economy.
3. Прочитать сохранённый подписанный сертификат; предъявить **внутреннюю** подпись и идентификационные поля.
4. Использовать существующие три ключа пользователя. Root + blockchain подписывают актуальную запись PDA по правилам Solana; registrar private key не участвует в upgrade.
5. Сформировать новую Solana транзакцию; оплатить PDA и комиссию; дождаться корректного on-chain результата.
6. Синхронизация связывает PDA с **тем же normalized full login**; меняет регистрацию на `PAID_UPGRADED` без новой logical-user строки.
7. Не сбрасывать старые Arweave блоки, used bytes, channel ownership, connections, profile, DM адресацию, session state.
8. В интерфейсе после синхронизации показывать «Зарегистрирован в Solana», разрешать обычную key rotation/access-server operations.
9. Если Solana транзакция упала или UI перезагрузился — пользователь остаётся бесплатным, сертификат и история сохранены, повторная попытка безопасна.
**Готово, когда:** пользователь Bob создал публикации/канал будучи free, оплатил Solana и затем видит все старые данные теми же ключами и именем.
## ЭТАП 13. Сквозные тесты, тестовый релиз и выпускная проверка
**Зависимость:** этапы 0–12.
**Стенд:** localnet/devnet Solana; отдельная тестовая PostgreSQL; тестовый сервер SHiNE; Turbo (помнить, что публикация может быть реальной и долговечной); второй независимый тестовый сервер.
**Сценарии приёмки:**
1. `create_namespace(@shine, type1)` и `create_namespace(@free, type2)` выполняет upgrade authority; посторонний отклонён.
2. Economy init разрешён любому, update только upgrade authority.
3. Серверный аккаунт регистрируется полноценным full login и имеет доступный server profile; free namespace ссылается на реально разрешаемый сервер.
4. `alice@shine` direct paid: PDA создан, сумма правильная, вход/профиль/публикации работают.
5. `bob@free`: три пары ключей генерируются локально, код 1111 принят, внутри и снаружи подпись правильная, email hash опубликован без email.
6. Turbo ACK → быстрый локальный импорт → вход Bob **без ожидания Arweave height**.
7. Независимый сервер импортирует Bob через Arweave и распознаёт тот же namespace/identity.
8. Повторный login/email отклоняется, повторный импорт того же DataItem идемпотентен.
9. Подменённый inner signature/root/client/blockchain/namespace/owner не проходит.
10. Bob не может менять ключи/access server до оплаты, включая прямой серверный вызов.
11. Bob создаёт профиль, публикацию, канал, связь и сообщение до Solana PDA.
12. Bob делает платный upgrade с сертификатом. Проверяются адрес PDA, fee, неизменность имени/3 ключей/блоков и отсутствие дублирующего пользователя.
13. После upgrade доступны штатные операции PDA/update/key rotation/access-server (по существующим ограничениям).
14. Перезапуск каждого сервера, новая БД + snapshot, обработка GraphQL повторно, задержка Turbo и Solana RPC не портят данные.
15. Две цены namespace ведут к двум разным корректным платежам.
16. Старые экраны, каналы, ссылки, DM, websocket auth, поиск, статистика и публикации не деградируют.
17. Проверить все места `getProgramAccounts`/PDA derivation; old seed не используется для **новых** регистраций.
18. Фактические сборки и тесты Rust/JS/Java, списки skip/fail, ручной smoke browser.
19. Обновлены документы Solana, DB, sync, API и runbooks. Разрешения на изменение API/формата соблюдены.
20. Все runtime secrets вне Git/logs/browser и test fixtures. Секрет регистратора не возвращается ни одним API.
**Только после этого:** отдельная подготовка к production, backup и план переключения. Сам факт прохождения devnet **не является разрешением** деплоя на боевой контур.
---
# Д. ОСОБЫЕ ЗАВИСИМОСТИ И СЛОЖНЫЕ УЧАСТКИ
## Д1. Первоначальное развёртывание — устраняем «курица или яйцо»
Один бесплатный namespace содержит **полный login сервера доступа**, а сервер сам является user PDA. Поэтому при развёртывании чистого проекта придерживаться порядка:
1. Deploy тестовой `shine_users`, затем economy init.
2. Upgrade authority создаёт платный namespace, например `@shine`.
3. Создать **платный серверный аккаунт** с полным именем вроде `server@shine`, оформить ServerProfileBlock и адрес сервера.
4. Настроить в тестовом сервере публичный/временный приватный registrar key.
5. Upgrade authority создаёт `@free` type2, указывая public registrar key и **уже зарегистрированный** `server@shine`.
6. Синхронизировать namespaces/server account во всех тестовых серверах; только после этого открывать бесплатную регистрацию.
Иначе free-пользователи получат несуществующий access-server login и не смогут подключаться.
## Д2. Данные после перехода free → paid
Создание Solana PDA — это **изменение статуса идентичности**, не новое начало пользовательского блокчейна. В E2E сравнивать до/после как минимум: fullLogin, 3 ключа, hash последнего блока, количество/ID публикаций, каналов, связей, значение used bytes, доступность DM. Не менять `blockchain_name` произвольно.
## Д3. Консистентность подписей
`inner signature` подтверждает только идентичность (имя + 3 публичных ключа), а **не email**. Solana проверяет `inner_message`, а не внешний DataItem и не email hash. Сервер, импортирующий Arweave, проверяет **обе** подписи и наличие email hash. Изменение email hash без нового ANS-104 DataItem изменит внешнюю подпись/ID, но не внутреннюю; это ожидаемое разделение функций.
## Д4. Синхронизация Solana против Arweave
Источник on-chain регистрации — Solana PDA. Источник бесплатной регистрации — подписанный Arweave DataItem. Локальная PostgreSQL — **индекс и рабочая проекция**, не третий независимый источник правды. При рестарте восстанавливать один и тот же логический набор. До Arweave confirmation локальная видимость законна после Turbo ACK, но межсерверная не обязана быть мгновенной.
## Д5. Нельзя оставлять обход для free-ограничений
Не ограничиваться disabled-кнопками. Free identity должна быть read-only по части **ротируемых прав** во всех server-side обработчиках. Для платного пользователя управление изменениями выполняется через существующий Solana PDA; нужно проверять, что после upgrade не осталось fallback на старый free certificate как источник прав смены ключей.
## Д6. Legacy программы и история
В этой версии нет миграции старых коротких Solana логинов. Не удалять старые PDA «для чистоты», не пересоздавать production. Удаление `promo_seller` из новой логики не означает обязательного удаления существующих PDA в блокчейне или программы `shine_login_guard`; это отдельное решение.
## Д7. Правила, которые не стоит молча менять
- Цена едина для всех имён одного namespace, нет premium tiers.
- Подпись регистратора не включает email.
- Один физический источник подписи пока программный.
- Код подтверждения строго `1111` и явно маркирован тестовым.
- Namespace creation через upgrade authority, economy-init остаётся открытым.
- Нет исправления угрозы украденного registrar key.
- Не меняются три ключа, логин, пользовательская цепочка при upgrade.
- До upgrade сервер доступа определяется только namespace.
Если рабочий код требует продукта, меняющего эти правила, **остановиться только по конкретному архитектурному противоречию**, не изобретать новый продукт. Мелкие инженерные вопросы решать в соответствии с протоколом и фиксировать в документации.
---
# Е. ПОШАГОВАЯ МАТРИЦА РЕЗУЛЬТАТОВ
| № | Выходной артефакт | Не начинать без | Минимальный тест готовности |
|---:|---|---|---|
| 0 | Исходный аудит и status file | Архив/репо | baseline и карта SQL зависимостей |
| 1 | Протокол + fixtures | 0 | одинаковые байты Rust/Java/JS |
| 2 | create namespace + authority | 1 | 2 namespace, чужой signer отклонён |
| 3 | Solana register 2 types | 2 | on-chain create paid/free-upgrade |
| 4 | JS codecs, tx builder | 3 | сериализация, реальные Solana tests |
| 5 | Unified PostgreSQL identity | 1, 3 | free identity без fake PDA |
| 6 | Sync Solana | 3, 5 | snapshot/history = одинаковая БД |
| 7 | Registrar signer stub | 1, 5, 6 | 2 подписи валидны |
| 8 | Arweave registration importer | 5–7 | локально сразу, второй сервер потом |
| 9 | WS free registration API | 7–8 + API approval | успешный WS flow |
| 10 | Auth/free permissions | 5, 8, 9 | login works, rotation blocked |
| 11 | UI registration | 4, 9, 10 | free и paid через браузер |
| 12 | UI upgrade | 3, 4, 6, 10, 11 | free→paid без новых данных |
| 13 | E2E / devnet / release checks | 0–12 | full regression suite |
**Условие завершения:** одно слово «готово» ничего не означает без доказанных тестов и списка изменённых файлов.
---
# Ж. СТАНДАРТНЫЙ ОТЧЁТ ПОСЛЕ КАЖДОГО ЭТАПА
В конце каждого этапа исполнитель обязан заполнить текст ниже и сохранить в `docs/registration-v2/IMPLEMENTATION_STATUS.md` (или приложить файл, если исходный репозиторий на этом этапе недоступен):
```text
SHiNE Registration V2 — журнал выполнения
Дата и время:
Базовая ветка / коммит / архив:
Этап №:
Статус: COMPLETED / PARTIAL / BLOCKED / NOT STARTED
1. Что было поручено:
2. Что реально изменено (полный список файлов):
3. Новые форматы / op codes / DB migrations / конфиги:
4. Команды сборки и тестов + результаты:
5. Ручная проверка и её фактический результат:
6. Что НЕ сделано или не проверено:
7. Совместимость с уже завершёнными этапами:
8. Обновлённые документы:
9. Коммит(ы) / diff / ссылка на патч:
10. Риски / открытые технические проблемы:
11. Следующий конкретный этап №:
12. Где следующий исполнитель должен начать чтение:
13. Нужны ли дополнительные разрешения по AGENTS.md:
Запрещено:
- считать partial этап завершённым;
- утверждать, что тесты прошли, если они не запускались;
- раскрывать секреты и реальные приватные ключи;
- деплоить production без согласования;
- менять формат пользовательских блоков незаметно;
- брать новую архитектуру «из головы» вместо этого документа.
```
**Контроль перед началом новой сессии:** открыть этот журнал, прочитать решения из раздела А, проверить статус этапов, продолжать с первого незавершённого этапа. Если исходник изменился, сначала обновить карту файлов и тестовые ожидания.
---
# З. КОНЕЧНАЯ ПРИЁМКА ПРОЕКТА
Работа завершена только если одновременно верно следующее:
- `[ ]` У каждого аккаунта формат полного логина `login@namespace`.
- `[ ]` Namespace-PDA обоих типов читаются любым сервером/клиентом.
- `[ ]` Namespace создаёт только действующая upgrade authority.
- `[ ]` Update economy контролируется upgrade authority; init economy остался публичным.
- `[ ]` PDA seed использует SHA-256, 32 сырых байта и полное имя.
- `[ ]` У paid direct есть полноценный PDA; цена берётся из namespace.
- `[ ]` Бесплатный DataItem содержит публичные ключи, две подписи и хеш email, но не секреты.
- `[ ]` Сертификат проходит внутреннюю Solana проверку и внешнюю ANS-104 проверку.
- `[ ]` Free user появляется локально после Turbo ACK без ожидания Arweave height.
- `[ ]` Другие серверы догоняют через Arweave sync, не создавая дублей.
- `[ ]` Free user реально входит и пользуется каналами/публикациями/связями/сообщениями.
- `[ ]` У free нельзя сменить ключи или access server через UI и через сервер.
- `[ ]` Free user платит за создание PDA, предъявляет сертификат и получает status paid.
- `[ ]` После upgrade сохраняются логин, три ключа, блокчейн, история, каналы, связи.
- `[ ]` Нет `shine_login_guard`/`promo_seller` в новом registration flow.
- `[ ]` Тестовые ошибочные подписи, суммы, seed, дубли и retry обрабатываются корректно.
- `[ ]` PostgreSQL migration/restart и Solana snapshot/history восстанавливают одинаковую картину.
- `[ ]` Документация соответствует Rust/Java/JS и текущему коду API.
- `[ ]` Тестовый стенд пройден; production не тронут без отдельного разрешения.
**Финальное правило:** если новая регистрация работает, но пользователь теряет прежние данные при upgrade, **патч не готов**. Сохранение единой личности — центральное требование всей работы.
@@ -0,0 +1,24 @@
# SHiNE — два состояния регистрации (DB v35, 26 октября 2026)
Актуальное продуктовое правило: **`FREE_CERT`** — есть серверный сертификат в Arweave,
но нет Solana PDA; **`PAID`** — подтверждён пользовательский PDA в Solana.
`PAID` равнозначен для прямой регистрации и перехода `FREE_CERT → PAID`.
- Логин, namespace и первые три ключа при переходе не меняются.
- `registered_at_ms` у перешедшего пользователя остаётся датой исходной регистрации.
Дата создания PDA остаётся в отдельном on-chain/account snapshot.
- Исходные Arweave DataItem и `free_registration_certificate` сохраняются для проверки
исторических событий; отдельная статистика способа регистрации не добавляется.
- В `migration_v35.sql` старые `PAID_DIRECT`/`PAID_UPGRADED` конвертируются в `PAID`,
статус ограничивается двумя значениями, а Solana sync-триггер при каждом upsert пишет `PAID`.
- `GetRegistrationStatus` возвращает `FREE_CERT`, `PAID` или `NOT_FOUND` для отсутствующего
логина. Новых API-полей или операций нет.
- В настройках предложение закрепить аккаунт видно только для `FREE_CERT`. После подтверждения
Solana PDA и серверной синхронизации пользователь видит поздравление и предложение исчезает.
- Промежуточная совместимость в UI допускает чтение старых платных статусов со старого сервера,
но после DB v35 они не хранятся и больше не генерируются.
- Не изменять исторические миграции v33/v34 и старые планы этапов: они отражают прежние
этапы проекта. Источником актуального состояния является этот документ и DB v35.
Перед обновлением production необходима резервная копия PostgreSQL и реальное
интеграционное тестирование миграции, синхронизации и повторного входа.
@@ -0,0 +1,42 @@
# SHiNE — накопительный патч 0–13: дополнения 9, 11–13
**База:** `SHiNE-bundle-2026.10.23-12.36.02.zip`; патч включает все изменения 0–10 и последние дополнения. **Дата:** 2026-10-23. **Статус:** тестовый кандидат, NOT PRODUCTION READY.
## Этап 9 (завершение подключения API — PARTIAL)
Владелец согласовал шесть новых WS `op`: `GetNamespaces`, `CheckRegistrationLogin`, `CheckRegistrationEmail`, `StartFreeRegistration`, `ConfirmFreeRegistration`, `GetRegistrationStatus`. Проверка имени и email — две независимые операции и два экрана UI. Код интегрирован через Bridge SPI (`shine-server-net-protocol` ↔ `shine-server-archive`), поднимается в `WsServer` без циклической зависимости Gradle. Реестр API и docs/API обновлены.
- Внутренняя Java-машина заявок сохраняет один подписанный ANS-104 DataItem на challenge, повторное подтверждение до TTL использует те же байты.
- Почтовый код `1111` учебный, факт владения email НЕ подтверждает.
- Код ответа `TURBO_ACCEPTED` отличается от `ARWEAVE_CONFIRMED`.
- Введены базовые ограничения частоты запросов (30 на соединение и 1200 глобально за минуту); не заменяют IP/rate limiting на reverse proxy.
- Debug-логи регистрации редактированы, чтобы не записывать email/публичные ключи и содержимое challenge.
- Если регистратор отключён в конфиге, список namespaces и проверки доступны, выдача сертификатов не работает.
## Этап 11 — регистрационные экраны (PARTIAL)
`register-view`: переключатель «Solana / бесплатно», on-chain список namespace через сервер, `login@namespace`, пароль, отдельный запрос доступности имени, исходный KDF Argon2id на полном имени и пароле, сохранение черновика в рамках текущего сеанса. Для платного переход в старую (адаптированную) страницу оплаты. Для бесплатного новая `registration-email-view`: запрос доступности email → временная заявка → код `1111` → Turbo → попытка штатного авто-входа. Ключи генерируются только локально; API передаёт только три публичных ключа в Base64.
Требуется реальный браузерный E2E: итоговый экран входа и маршрутизация бесплатного пользователя не проверены.
## Этап 12 — upgrade бесплатного аккаунта в Solana (PARTIAL)
В настройках у `FREE_CERT` появляется кнопка «Зарегистрировать аккаунт в Solana». Экран запрашивает статус и внутреннюю подпись регистратора, получает цену из реального namespace-PDA Solana, повторно выводит прежние 3 ключа **из того же полного имени и исходного пароля**, проверяет совпадение трёх публичных ключей с сертификатом и использует существующий транзакционный конструктор `upgradeFreeUserOnSolana`. Не создаёт новый логин/ключи/историю; не объявляет upgrade успешным до подтверждения синхронизации PDA.
Отдельно потребуется тестировать экономику, rent, реальный Solana RPC, состояние пользователя в БД и неизменность контента.
## Этап 13 — подготовка E2E (PARTIAL)
`VALIDATION_STAGE_13.md` содержит 20 контрольных требований и порядок стендовой проверки. Добавлены статические контрактные JS тесты. Проведено:
- `node --test tests/*.test.mjs tests/*.test.cjs` → **28/28 OK** на JS-коде текущего патча.
- `node --check` новых/изменённых JS файлов → OK.
- Изолированный `javac --release 17` для новых API/Java workflow классов со заглушками отсутствующих модулей → OK; это НЕ реальная серверная сборка.
- Полная Gradle-сборка из корня не выполнена: wrapper требует скачать Gradle 8.14, DNS недоступен.
- Rust Solana (cargo/anchor) и PostgreSQL E2E в этом окружении отсутствуют.
**Критическое исправление:** из трёх существовавших экранов test-topup убран публично встроенный приватный ключ отправителя и автораздача из браузера. Доступно только ручное пополнение из внешнего devnet faucet. Ранее опубликованный тестовый ключ следует считать скомпрометированным.
## Фактически не проверено / не завершено
Solana localnet/devnet; миграции PostgreSQL v33/v34 на пустой и существующей базе; реальные Rust/Gradle сборки; двойная подпись + настоящая Turbo публикация, GraphQL discovery на другом сервере, login/profile/channel/DM на FREE_CERT, запись/смена ключей только после upgrade, безопасность и отказоустойчивость перезапуска. До выполнения этих проверок **нельзя использовать патч на production**.
@@ -0,0 +1,31 @@
# Объединённый патч SHiNE — этапы 1, 2 и 3
**Исходная база:** этап 0, архив от 23 октября 2026 г. **Ветка отсутствует** (в ZIP нет .git).
## Содержимое
- Этап 1: бинарные протоколы namespace/certificate, Rust/Java/JS детерминированные векторы и реальный подписанный тестовый DataItem ANS-104.
- Этап 2: `IX_CREATE_NAMESPACE=7`, сериализация/парсинг namespace 1.0, SHA-256 namespace PDA, authorization через ProgramData, `IX_UPDATE_USERS_ECONOMY_CONFIG` с новой authority, economy read-only.
- Этап 3: новые SHA-256 user PDA для полного `login@namespace`, цена из namespace, проверка `Ed25519` inner certificate для типа 2, прямое платное создание типа 1, обновление v1.2, legacy-update fallback, исключение guard/promo из новой регистрации.
## Что ещё НЕ доказано и НЕ готово
- Нет Rust/Solana toolchain в доступном окружении — **Rust программа не собрана и не проверена localnet/devnet**. Изменения в Rust требуют дополнительной компиляции и интеграционных тестов до merge/деплоя.
- В старом браузерном UI, Java Sync и серверной API нет нового формата аргументов и namespace; **платная регистрация с прежним UI станет несовместимой после преждевременного deploy**. Поэтому деплой категорически исключён.
- Нет Solana BPF integration tests транзакций `create_namespace`, `create_user` и upgrade; добавлены код и векторы Rust/JS/Java, но полноценную готовность этапов 2–3 **не утверждаем**.
- Сервер-регистратор, база, email, Turbo, локальный импорт, сохранение уже потраченного лимита и E2E — следующие этапы, не этот патч.
- Формат on-chain `created_at_ms` новой PDA оставлен текущим Solana временем. Реальную первую дату и уже использованный бесплатный бонус нужно сохранить в общем индексе идентичности этапов 5–6; on-chain выдача дополнительного стартового бонуса может потребовать изменения механизма лимитов на следующих этапах до эксплуатации.
- Перед production требуется отдельное согласование релиза и проверка существующего UI/сервера с новой программой.
## Проверки
```bash
cd shine-solana/shine
node --test tests/registration-v2-vectors.test.mjs
javac --release 17 -d /tmp/shine-reg-v2 tests/java/RegistrationV2VectorsCheck.java
java -cp /tmp/shine-reg-v2 RegistrationV2VectorsCheck tests/fixtures/registration-v2.properties
cargo test --test registration_v2_vectors # нужен Rust toolchain
cargo build --manifest-path programs/shine_users/Cargo.toml # нужен Rust toolchain
```
Дополнительно UI baseline: `node --test shine-UI/tests/*.test.*` из корня.
@@ -0,0 +1,40 @@
# SHiNE — накопительный патч этапов 0–7 (новые изменения 4–7)
**Основа:** в точности каталог исходников ZIP `SHiNE-registration-stages0-3-combined-2026.10.23.zip`. Без Git/commit, никаких deploy/запросов к production не производилось. Нумерация — 14 этапов из `MASTER_PLAN_V2_2026-10-23.md`.
## Внесённые изменения
**Этап 4 / UI Solana codec (код):** `shine-namespace-service.js` с нормализацией, deriveUserPda/deriveNamespacePda, read/list/decode/encode namespace; переписан create-user ix под `[payer,userPda,system,inflow,instructions,economy,namespace]`, с регистраторским `Ed25519 IX`, `root IX`, `blockchain IX`, `create IX` в этом порядке, новый байтовый суффикс option `registrarSignature64`, цены из namespace; `upgradeFreeUserOnSolana` использует уже существующие ключи и исходную подпись. Обновлены PDA reads/updates, сохранены legacy PDA seed для имён без `@`. Старый `precheckLoginClassOnSolana` заблокирован явной ошибкой (не возвращает фальшивый legacy результат), UI-экраны будут переделаны на этапе 10. Создание server-PDA использует тот же общий сервис и теперь тоже требует `login@namespace`.
**Этап 5 / PostgreSQL (миграция, не применена):** `migration_v33.sql`, таблица `user_identity_current` (с настоящим `solana_pda_address = NULL` у FREE_CERT), `shine_namespace_current`, `free_registration_certificate`, backfill старых PDA, перелинковка FK, триггер `Solana→user identity`, запрет замены трёх ключей при upgrade, обновлённый local-routing по `namespace.default_server_login`, `CurrentUsersSql`, `CurrentUsersDAO.searchDirectory` и `UserAccessServersCurrentDAO`. Новая схема применяется `DatabaseInitializer` после v32; исторические миграции не переписывались. **Требуется PostgreSQL integration test и аудит всех business-DAO перед деплоем.**
**Этап 6 / Solana Users Sync (код):** `IX_CREATE_NAMESPACE=7` распознаётся в history, бинарный namespace декодируется отдельно, адрес проверяется через `SHA256(namespace=...)`, `SHA256(user_login=...)` для новых пользователей; snapshot и history умеют получать namespace + user, атомарно upsert в PostgreSQL вместе с checkpoint, повторный on-chain snapshot не удаляет free-пользователей; `PostgresStorageRepository.migrate()` больше не перезаписывает функции v33 устаревшими Solana-only. Кодек и PDA проверены на известном векторе Java. Полный RPC/DB history replay **не выполнялся**.
**Этап 7 / Java registrar (код):** интерфейс `RegistrarSigner`, локальный seed signer с конфигурацией вне Git, бинарный codec, формирование внутреннего Ed25519+внешнего ANS-104 с точными тегами и верификацией, `FreeRegistrationIssuer` проверяет доверенное namespace-PDA из синхронизированного реестра, занятость login/email и тестовый код `1111`. **Пока только выпускает raw signed bytes, не передаёт Turbo и не активирует пользователя** — это этап 8. Отдельный тест `FreeRegistrationCertificateV1Check` сверяет существующий JSON-фиксированный DataItem и отбрасывает искажения.
## Обязательные проверки, которые реально прошли
```text
node --test shine-UI/tests/*.test.* 23/23 passed
node --test shine-solana/shine/tests/registration-v2-vectors.test.mjs 6/6 passed
javac + java server.archive.FreeRegistrationCertificateV1Check ... PASS
javac + java sync.codec.NamespaceV2VectorCheck ... PASS
javac (partial) Java codec/repository с offline заглушками зависимостей PASS
node --check JS изменённых модулей PASS
```
Заглушки только в `/mnt/data/shine_java_stubs` (не входят в артефакт) для компиляции без Jackson/SLF4J. Это **не заменяет** полноценную сборку Gradle.
## Что не проверено, почему нельзя включать новую регистрацию в production
1. `cargo test`, `anchor build`, Solana localnet/devnet, транзакции регистрации и реальный devnet upgrade не запускались; Rust, как в предыдущем патче, пока не прошёл on-chain проверку.
2. PostgreSQL миграция v33 **не исполнялась на настоящем PostgreSQL**; динамическая перелинковка FK и триггеры требуют временной БД и резервной копии. Запускать только в изолированном контуре после одобрения.
3. Java Sync не проходил полноценный Gradle build/RPC/history replay/PostgreSQL integration; компилировались только отдельные части.
4. Java issuer не подключён к жизненному циклу сервера и WS API: без явного согласования проекта новые public operations добавлять нельзя.
5. Free-пользователь пока не активируется после Turbo: нет этапа 8 (импорт), этапа 9 (WS API), этапа 10 (полного UI), этапов 11–13 (E2E/релиз согласно мастер-плану).
6. Начальный бесплатный лимит при upgrade не должен начисляться дважды: Rust-контракт требует дополнительного on-chain решения/теста до включения оплаты. Штатные приватные ключи никогда не должны покидать браузер.
7. Не тестировались PostgreSQL миграционные объекты при одновременной синхронизации и update key rotation. Не включать флаги на действующем сервере.
## Рекомендованный следующий блок
Строго этап 8: raw signed DataItem → Turbo upload → **те же bytes** в idempotent локальный verified importer → последующий независимый Arweave discovery. Не менять public WS API до отдельного согласования операции/полей. Затем этап 9 для WS и этап 10 для пользовательских форм.
@@ -0,0 +1,28 @@
> **Исторический отчёт:** раздел «9 — WS API не включено» относился к состоянию патча 0–10. В накопительном патче 0–13 API включены; см. `PATCH_STAGES_11_12_13.md`.
# SHiNE — накопительный патч 0–10: изменения 8–10
**База:** точный каталог из `SHiNE-registration-stages0-7-CUMULATIVE-2026-10-23.zip`. Архив 0–10 строится поверх него. Не production-ready; он только исходники и документация. Разработчикам по-прежнему нужны localnet Solana, тестовая PostgreSQL и Gradle сборка.
## 8 — Arweave и Turbo (реализовано частично)
- `VerifiedFreeRegistrationImporter` — новый отдельный путь `t=reg`, отказывается принимать пользовательский BchBlock как сертификат. Проверяет структурный АНS-104, внешнюю Ed25519 и внутреннюю подпись, подписанта из namespace-PDA через реестр, полное имя и минимальную длину, транзакционную уникальность login/email; различает `TURBO_ACCEPTED` и `ARWEAVE_CONFIRMED`; повтор того же сырого DataItem не дублирует личность.
- `FreeRegistrationPublisher` предварительно проверяет сертификат и занятость имени/email до HTTP, затем отправляет уже подписанный DataItem через существующий `TurboDataItemUploader`; только после его успешного ACK вызывает тот же локальный importer. При unknown Turbo outcome не заявляет успех.
- `ArweaveBlockSyncService` распознаёт `t=reg` до обычной block queue, отдельно вычитывает GraphQL `App=test5592 AND t=reg` и хранит собственный checkpoint (`migration_v34.sql`). После появления height независимые серверы импортируют сертификат, повторное обнаружение подтверждает `ARWEAVE_CONFIRMED`.
- **Проверить в реальной сети:** Arweave gateway / GraphQL фильтрация / root-range доступность и работу с несколькими серверами. Нет фактического Turbo upload и PostgreSQL integration; нельзя считать этап завершённым.
## 9 — WS API (подготовка, публичное API не изменено)
- Внутренний `FreeRegistrationWorkflow`: реестр namespace, precheck, 15-минутный временный challenge, `1111`, однократно сформированные raw bytes, тот же DataItem при повторе, status lookup.
- См. `WS_REGISTRATION_V2_PROPOSED_NOT_ENABLED.md`. По правилу `AGENTS.md` точные имена/поля/ErrorCodes требуют отдельного подтверждения. `JsonHandlerRegistry`, сериализация новых публичных запросов и действующая документация `docs/API/` **не изменены**; обычным WS-клиентом пройти free регистрацию пока нельзя.
## 10 — единая авторизация и запреты free (частично)
- `RegistrationIdentityDAO.ResolvedIdentity` хранит источник, статус, namespace, root/blockchain/client keys, сервер доступа, `hasSolanaPda` (для FREE_CERT он false).
- `SolanaUserPdaImportService.checkSessionTypeAgainstPda` не пытается получить несуществующий Solana PDA бесплатного пользователя; существующая подпись по clientKey и nonce остаётся обязательной.
- Семь обработчиков процедуры KeyRotation вызывают серверную проверку прав: `FREE_CERT` запрещён вне зависимости от состояния UI. При ошибке БД guard fail-closed. Для upgrade source становится Solana, key rotation продолжает соблюдать прежний Solana порядок.
- Новые ошибки существующих KeyRotation handlers (`KEY_ROTATION_PAID_ONLY=403`, `KEY_ROTATION_IDENTITY_UNAVAILABLE=503`) **нужно согласовать** до вывода этого кода на публичный сервер, согласно правилам API.
- **Не подтверждено:** сквозной login, поток полной истории и DM для free, смена ключей после upgrade, полная проверка альтернативных путей доступа и реальная работа на PostgreSQL.
## Итоги/ограничения
- Существующие форматы пользовательских блоков не изменены, namespace/certificate — отдельный формат `t=reg`.
- Не записано никаких данных в Solana/Arweave, не сделан deploy или git commit.
- Новый Java код компилируется частично через тестовые локальные заглушки зависимостей; это **не** полная Gradle сборка.
- До production обязательно: Rust+Anchor localnet, Gradle, PostgreSQL v33/v34 миграция и тест отката, GraphQL/Turbo, проверка API, E2E двух серверов и права бесплатного пользователя.
@@ -0,0 +1,15 @@
# Локальный регистратор SHiNE, этап 7
Модуль `shine-server-archive/server.archive.registration` выдаёт **сырой signed ANS-104 DataItem**, но **не публикует** его и **не создаёт пользователя** (это этап 8). В этот патч публичный WS/API не добавлялся.
## Конфигурация
- `freeRegistration.enabled=false` по умолчанию. Включается только на тестовом сервере после проверки соответствия namespace.
- `freeRegistration.registrarSeedFile` — абсолютный путь к файлу вне Git, внутри одна Base64-строка **32-byte Ed25519 seed**. Пример имени `/var/lib/shine/secrets/registrar-seed.b64`; не создавать файл с тестовым ключом внутри репозитория.
- `LocalRegistrarSigner.fromConfig(AppConfig)` проверяет enabled и наличие пути, не печатает секрет или bytes в лог.
- Публичный ключ signer должен совпадать с `shine_namespace_current.registrar_pubkey` (из on-chain namespace), иначе `FreeRegistrationIssuer.issue` отказывает.
- При включённой бесплатной регистрации обязательно задать `RESEND_API_KEY` в окружении процесса (или `freeRegistration.email.apiKey` в защищённом внешнем конфиге). Настройки: `freeRegistration.email.allowTestCode=false` — временный обход `777777`, `freeRegistration.email.allowReuse=false` — запрет повторного использования одного email, `freeRegistration.email.from=SHiNE <noreply@shineup.me>` — отправитель. `allowReuse=true` допустим только в закрытом тестовом окружении: при этом один email может завершить несколько регистраций. Тестовый обход включать исключительно в закрытом тестовом окружении. 6-значный код отправляется на email через Resend и проверяется до выдачи сертификата. Подробности: [RESEND_EMAIL_VERIFICATION.md](RESEND_EMAIL_VERIFICATION.md). Регистрация окончательно не активируется до Turbo ACK и проверенного импорта.
**Безопасность:** на реальном сервере ограничить права файла регистратором/пользователем Java-процесса (0600), не сохранять секрет в stdout, crash reports, Git, backup без шифрования. В будущем заменить реализацию `RegistrarSigner` на аппаратный модуль.
В `issue()` проверяются текущие известные login/email и namespace; эта проверка сама по себе не резервирует имя. Этап 8 обязан транзакционно повторить проверки и гарантировать уникальность с `UNIQUE` индексами БД.
@@ -0,0 +1,62 @@
# Подтверждение email при бесплатной регистрации SHiNE
Реализация: `SHiNE-server/shine-server-archive/src/main/java/server/archive/registration/`.
## Подключение Resend
1. В Resend подтвердить `shineup.me` (DNS DKIM + отправляющие CNAME), статус **Verified**.
2. Получить в Resend API key с правом `Sending access`.
3. Указать API-ключ как `RESEND_API_KEY` в окружении Java-процесса (предпочтительно) или через `freeRegistration.email.apiKey` во **внешнем**, недоступном из Git `application.properties`. Никогда не коммитить реальный ключ, не печатать в журнале и не отдавать клиенту.
4. Настройка `freeRegistration.email.from`. По умолчанию отправитель: `SHiNE <noreply@shineup.me>`.
При необходимости изменить внешним параметром `freeRegistration.email.from`, но адрес обязан относиться к подтверждённому домену.
5. Настройка `freeRegistration.email.allowTestCode=false` по умолчанию. Только для тестирования `true` разрешает код `777777` на этапе подтверждения любой активной заявки. Это полностью обходит подтверждение владения email и НЕ ДОЛЖНО использоваться на публичном/production-сервере.
6. На сервере, где `freeRegistration.enabled=true`, без API-ключа Resend старт завершится ошибкой (fail-closed), даже если тестовый код включён. При создании заявки письмо всегда отправляется.
7. После локальных тестов перезапустить только нужный тестовый сервер по инструкциям deploy (production отдельно согласовывать).
## Процесс
- `CheckRegistrationEmail` проверяет известный занятый email, без отправки.
- `StartFreeRegistration` создаёт случайный 6-значный код и challenge, отправляет письмо через HTTP API Resend;
только после ответа 2xx возвращает `challengeId` и `expiresAtMs`.
- `ConfirmFreeRegistration` принимает код для конкретного challenge. После верного кода
подписывает сертификат и публикует прежним Turbo/Arweave путём. Формат WS/API и сертификата не меняется.
- Код действует 1 час, хранится в памяти как SHA-256(challengeId + `:` + code), максимум 5 ошибок на challenge.
Повторная отправка ограничена одной попыткой в минуту на email и логин. Общий лимит — 60 отправок в час
на процесс. Повторная публикация сертификата после сетевой ошибки допускается до конца TTL.
- Данные challenge в памяти: после перезапуска сервера ещё не подтверждённый код перестаёт действовать;
пользователь начинает новую заявку. Для нескольких Java-инстансов понадобится общее хранилище TTL (Redis/Postgres),
иначе challenge, созданный на одном узле, не подтвердится на другом.
- При HTTP-ошибке Resend заявка удаляется, код не считается отправленным.
## Проверка
1. Для тестового окружения задать `RESEND_API_KEY` в systemd EnvironmentFile (файл с ограниченными правами),
не добавляя ключ в репозиторий. При изменении секрета перезапустить сервис.
2. Зарегистрировать новый `login@free` и доступный адрес email.
3. Проверить письмо, неверный код, истечение срока, пять ошибок, повторную отправку через минуту,
успешное подтверждение, Turbo ACK и отсутствие email/кода в системных журналах.
4. Проверить ошибки/квоту Resend в панели провайдера и корректное поведение UI.
Сервис Resend может принять запрос на отправку, но не гарантирует доставку во входящие пользователя;
статусы доставки анализируются в панели Resend, особенно для bounce/spam.
## Три настройки сервера
```properties
# Реальный секрет предпочтительно задавать через RESEND_API_KEY или внешнюю конфигурацию.
freeRegistration.email.apiKey=
freeRegistration.email.allowTestCode=false
freeRegistration.email.allowReuse=false
freeRegistration.email.from=SHiNE <noreply@shineup.me>
```
Параметры читаются из `AppConfig`: системное свойство → переменная окружения
(`FREE_REGISTRATION_EMAIL_API_KEY`, `FREE_REGISTRATION_EMAIL_ALLOW_TEST_CODE`,
`FREE_REGISTRATION_EMAIL_FROM`) → внешний `application.properties` → встроенный файл.
`RESEND_API_KEY` имеет приоритет над `freeRegistration.email.apiKey`.
Ограничение: чит-код действует **только для уже созданного challenge**, когда
Resend успешно принял запрос на отправку. Он не создаёт пользователя без
`StartFreeRegistration` и не работает после истечения 1 часа или перезапуска Java.
Для применения изменений настроек нужен перезапуск Java-процесса.
@@ -0,0 +1,251 @@
# SHiNE — план поэтапной реализации новой регистрации
**Версия плана:** 1.0, 23 октября 2026 года
**Исходный код:** `SHiNE-bundle-2026.10.22-12.53.20(1).zip`
**Статус:** планирование; код проекта этим документом НЕ изменён.
## 0. Конечная цель и неизменяемые договорённости
Один пользователь имеет глобальную идентичность `login@namespace`. Возможны три жизненных состояния: (а) сразу платно зарегистрирован в Solana; (б) бесплатно зарегистрирован сертификатом в Arweave без пользовательского Solana PDA; (в) тот же бесплатный пользователь, позднее оплативший Solana PDA. При (б) → (в) сохраняются полное имя, три публичных/приватных ключа пользователя (приватные всегда у пользователя), логика доступа и существующая история блокчейна.
- В Solana создаются PDA двух видов namespace: тип 1 — прямая платная регистрация; тип 2 — сертификат регистратора + последующая платная регистрация.
- В namespace записаны версия (два байта), тип, минимальная длина **части `login`**, название, цена регистрации `u64` lamports; для типа 2 — публичный ключ регистратора и полный логин сервера доступа.
- Общий максимум полного имени `login@namespace` — **30 UTF-8 байт**, пока допускаются ASCII `a-z0-9_` и ровно один символ `@`; это ограничение формата, не семантики PDA seed. Нормализация — единая: ASCII lower-case, без неоднозначного преобразования/усечения. Если требуется иное правило знаков, менять его только одновременно везде.
- PDA пользователя получают seed `SHA256(UTF8("user_login=" + normalized_full_login))` длиной 32 сырых байта. Namespace PDA получает отдельный доменно-разделённый SHA-256 seed; точное значение префикса зафиксировать до создания PDA и больше не менять.
- Создание namespace и изменение `users economy config` может авторизовать **действующая upgrade authority** программы через аккаунт ProgramData; инициализацию economy-PDA по-прежнему разрешено вызывать любому.
- Обновлять или удалять namespace пока нельзя. Старую классификацию `shine_login_guard` и `promo_seller` исключаем из **новой** регистрации. Автоматическая миграция legacy пользователей не требуется; в других программах удалять лишнее без необходимости не нужно.
- Economy-PDA остаётся аккаунтом только для чтения во всех новых Solana-транзакциях регистрации и создания namespace, поскольку его история используется как источник транзакций для синхронизации. Цена регистрации берётся из namespace, а параметры лимитов — из economy.
- Бесплатный сертификат: бинарные версия, полный логин, root/client/blockchain **публичные** ключи, внутренняя Ed25519-подпись регистратора от этих полей, затем SHA-256 нормализованного email. Внешняя подпись ANS-104 DataItem — тем же ключом, но **это другая подпись от другого сообщения**. Email не включён во внутреннюю подпись. Приватные ключи пользователя нигде не публикуются и серверу не передаются.
- Пока email-подтверждение демонстрационное, фиксированный код `1111`; в интерфейсе явно указать «тестовый код, реального подтверждения владения почтой нет». Хеш email в Arweave публичен и может подбираться: это принятое ограничение тестовой схемы.
- Временный ключ регистратора (секрет) читается из конфигурации сервера/переменных окружения вне git. Не писать секрет в репозиторий, открытые настройки UI, журнал или лог. В перспективе интерфейс подписания отделяется на аппаратный регистратор.
- Система не реализует в этом патче защиту от компрометации ключа регистратора и отдельный аппаратный журнал. Однако обязательны проверки обычных подписей/полномочий и запрет перезаписи уже зарегистрированного логина.
- Бесплатным пользователям запрещены смена root/client/blockchain ключей, смена access-server и форки, меняющие ключи. Обычные операции публикации и работы с контентом остаются.
- После Turbo-ответа об успешном приёме сразу запускается **тот же доверенный импорт подписанного DataItem локально**, без ожидания Arweave GraphQL/высоты блока. Принятие Turbo — не тождественно окончательному включению в блокчейн; хранить статус публикации отдельно.
## 1. Принципы исполнения — для всех этапов
1. Выполнять **по одному этапу за отдельный патч/сеанс**. Если этап большой, делить на два коммита, не совмещать с соседними этапами.
2. Перед работой сверить рабочую ветку с указанным исходным архивом; если код изменился, провести локальную переоценку затронутых файлов.
3. Никогда не смешивать deploy Solana с деплоем Java/UI. Не трогать production и реальные пользовательские данные без отдельного разрешения.
4. Обновлять документацию вместе с кодом по требованиям `AGENTS.md`, `shine-solana/shine/AGENTS.md`, `SHiNE-server/AGENTS.md`, `shine-UI/AGENTS.md`; правила коммитов — `COMMIT_AND_VERSION_RULES.md`.
5. Там, где меняется публичный серверный WebSocket/API-контракт или формат существующего блокчейна, отдельно перечислить изменения и получить предусмотренное репозиторием подтверждение **перед непосредственной модификацией**. Новый регистрационный DataItem не следует незаметно маскировать под обычный блок.
6. В конце этапа: результаты сборок/тестов, список изменённых файлов, что проверено реально, что ещё не работает, текущий статус следующего этапа.
7. Использовать тестовую сеть Solana и отдельную тестовую PostgreSQL/Arweave-конфигурацию. Настоящие ключи и почту не включать в тестовые фикстуры.
---
## Этап 1. Зафиксировать протоколы и сквозные тест-векторы
**Задача:** до написания смарт-контракта определить неизменяемый бинарный «контракт» между Rust, JS и Java.
**Где:** новый документ `shine-solana/shine/doc/formats/shine-namespace-pda-format-v1.md`; документ сертификата `docs/Протоколы/SHINE_FREE_REGISTRATION_CERTIFICATE_V1.md` (или близкое место в существующей структуре); обновить `shine-solana/shine/doc/programs/shine_users.md`, `docs/Solana_Architecture/README.md`, `docs/Инициализация_Solana_регистрации/README.md`.
**Действия:**
- Точно зафиксировать байтовую раскладку namespace: `[major:u8][minor:u8][type:u8][min_login_len:u8][namespace_len:u8][namespace:utf8][fee:u64 LE][type-2: registrar_pubkey(32), server_login_len:u8, server_login:utf8]` с явными правилами окончания, padding, размером аккаунта, owner и проверкой PDA. При желании разместить `magic` как дополнительное поле, **но сначала выбрать один окончательный формат**.
- Утвердить неизменные доменные префиксы для SHA-256 seed пользователя/namespace и подписи сертификата. Для сертификата использовать бинарное сообщение с версией, длиной логина и тремя `bytes32`, исключающее неоднозначную конкатенацию. Пример префикса: `SHiNE_FREE_REG_V1\0`; реальный префикс и порядок ключей определить только один раз.
- Зафиксировать, что бесплатный `login@free` сохраняет то же имя после Solana-оплаты; тип namespace не изменяется.
- Зафиксировать формат email-нормализации: trim, Unicode NFC, lower-case независимым от локали; **не** удалять точки и `+suffix`, потому что это зависит от провайдера. На всех серверах одна схема.
- Создать общие фикстуры с известными логинами, сырыми seed/hash, правильным и неправильным namespace, правильным/неправильным Ed25519 сертификатом и структурой DataItem.
- Зафиксировать политику начальных лимитов бесплатного пользователя: стартовый бонус из economy-PDA (без платежа), без покупки лимитов до on-chain регистрации либо с уже существующими допустимыми механизмами — не добавлять несанкционированные платежи.
**Готовность:** один и тот же набор байтов даёт одни и те же SHA-256, PDA, разбирается в Rust/JS/Java по тест-векторам. Документация определяет всё без догадок.
## Этап 2. Solana: пространства имён и полномочия
**Где:** `shine-solana/shine/programs/shine_users/src/lib.rs`, `.../src/settings.rs`; тесты в `shine-solana/shine/tests/`; обновить `doc/programs/shine_users.md` и новый документ формата.
**Действия:**
- Добавить `create_namespace` (новый ID инструкции), код сериализации/десериализации namespace, проверки имени, типа, длины, цены и публичного ключа регистратора.
- Создавать PDA только с рассчитанным адресом, не допускать дублирования; сверять owner программы и SystemProgram, выделять rent-exempt space.
- Реализовать проверку ProgramData/upgrade authority: аккаунт ProgramData обязан соответствовать **именно данной** upgradeable программе; signer обязан совпадать с её текущей upgrade authority. Отказывать, если программа immutable или передан поддельный аккаунт. Никаких «постоянных DAO ключей» в константах.
- Перевести `update_users_economy_config` с `DAO_AUTHORITY` на ту же проверку, не меняя разрешение `init_users_economy_config`.
- Передавать economy-PDA в `create_namespace` (read-only); проверять его корректный адрес.
- Подготовить локальный CLI/скрипт администратора для создания двух тестовых namespace с произвольной ценой и минимальной длиной.
**Тесты:** владелец создаёт, не-владелец не создаёт, чужой ProgramData не работает, одинаковый namespace второй раз создать невозможно, неправильные бинарные размеры не принимаются, economy-init доступен всем, economy-update — только upgrade authority.
**Готовность:** в localnet/devnet создаются и читаются два namespace; обычная регистрация пока может оставаться неработающей в промежуточной ветке.
## Этап 3. Solana: новая платная регистрация и upgrade из бесплатной
**Где:** `shine-solana/shine/programs/shine_users/src/lib.rs`, `settings.rs`, `shine-solana/shine/tests/shine.ts`; обновить формат PDA 1.2 и программу в `doc/`.
**Действия:**
- Перевести `find_user_pda` и `create_pda_account` на единственный 32-байтовый хеш seed, полное нормализованное имя, проверки 30 байт и минимальной длины части `login`.
- Обновить `create_user_pda`: передача namespace-PDA, чтение namespace-PDA и economy-PDA, установка комиссии `namespace.fee + цена дополнительных лимитов из economy`. Оставить текущие проверки подписи root и blockchain ключей, строгие записи пользователя v1.2 и оплату в существующий inflow-vault.
- Для namespace типа 1 разрешить прямую регистрацию без сертификата; для типа 2 требовать корректную внутреннюю Ed25519-подпись регистратора на полном имени и трёх **тех же** ключах; ключ регистратора брать **только** из namespace-PDA. Подписи проверять через Instructions Sysvar.
- Не разрешать создание PDA на чужое имя с другими ключами или неподписанным сертификатом.
- Удалить из новой инструкции обращения к `shine_login_guard`, promo seller PDA, промоподписи и код продавцов. Удалить `upsert_promo_seller` и относящуюся к нему новую логику.
- Обновить `update_user_pda` и другие действующие инструкции, вычисляющие адрес по имени; при этом формат пользовательского PDA v1.2 по возможности не менять, меняются условия create и способ адресации.
- **Особо:** существующая Solana-create проверяет `created_at_ms` относительно текущего времени. При upgrade бесплатный блокчейн мог существовать месяцами. Разделить «время создания Solana PDA» и «первое время существующего блокчейна» так, чтобы не обнулять историю и не отклонять старую регистрацию. Не разрешать произвольную фальсификацию исторических данных.
**Тесты:** namespace1 / namespace2, корректные/искажённые подписи, root/client/blockchain mismatch, точная сумма платежа, 30 байт, неверный namespace, чужой PDA, повторная оплата/создание, существующие update/fork правила, сохранение идентичности после upgrade.
**Готовность:** оба сценария Solana-перехода проходят в тестовой сети при прямом вызове инструкций (даже если UI/сервер ещё не готовы).
## Этап 4. JS: общие кодеки и Solana-клиент без UI
**Где:** `shine-UI/js/services/shine-user-pda-service.js`, `shine-UI/js/services/solana-register-service.js`, `shine-UI/js/solana-programs.js`; возможно новые модули `shine-UI/js/services/shine-namespace-service.js`, `shine-UI/js/services/free-registration-certificate.js`; тесты `shine-UI/tests/`.
**Действия:**
- Вынести вычисление полного нормализованного имени, seed SHA-256 и PDA в однозначные функции.
- Реализовать декодер namespace, список namespace из RPC (использовать RPC gateway существующего проекта), локальную проверку формы, цены, минимальной длины и типа.
- Переписать платную Solana-транзакцию под новые списки аккаунтов и инструкции; убрать `precheckLoginClassOnSolana`, обращения к `SHINE_LOGIN_GUARD_PROGRAM_ID`, promo параметры.
- Реализовать клиентский конструктор upgrade-транзакции из сертификата с Ed25519 verify instruction и подписями root/blockchain текущего пользователя.
- На клиенте **не генерировать новые пары ключей** при upgrade; использовать существующие ключи и прежний master-secret от **полного** `login@namespace`.
- Сравнивать адрес/стоимость, выведенные локально, с прочитанным namespace-PDA; ошибка чтения — не разрешать платёж вслепую.
**Тесты:** JS ↔ Rust test vectors, платная транзакция работает с тестовыми программами, отсутствуют вызовы login guard/promo.
**Готовность:** функции чтения, создания и upgrade доступны UI, но пока могут вызываться тестовыми скриптами.
## Этап 5. PostgreSQL: единая идентичность и синхронизация Solana
**Где:** новые миграции в `SHiNE-server/shine-server-db/src/main/resources/postgres/` (текущие миграции до `migration_v32.sql`); `SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/{codec/ShineUsersCodec.java,util/SolanaPdaUtil.java,service/SolanaUsersSyncService.java,storage/postgres/PostgresStorageRepository.java,source/rpc/SolanaRpcClient.java}`; `SHiNE-server/src/main/java/server/sync/SolanaUsersSyncStartupService.java`; документы `docs/Solana/SOLANA_USERS_SYNC_MODULE_DESIGN.md`, `deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md`.
**Действия:**
- **Сначала аудит всех FK/триггеров** к `solana_user_pda_current`: много таблиц, включая связи, пользователей, сообщения и блокчейны, зависят от неё. Нельзя просто добавить отдельную таблицу free-user и ожидать, что приложение их увидит.
- Выбрать и реализовать совместимый **единый индекс идентичностей**. Практичный путь: расширить существующую модель текущих пользователей признаками `registration_source=solana|arweave`, `has_onchain_pda`, идентификатором DataItem и сертификатом; адрес будущего PDA можно вычислить заранее, **но явно отмечать, что аккаунта on-chain ещё нет**, не подделывать слот/подпись транзакции. При необходимости вынести происхождение в отдельную связанную таблицу, чтобы не сломать старые ограничения.
- Создать таблицу namespace (PDA, тип, цена, ключ, server-login, slot/tx), таблицу Arweave сертификатов + hash-email и индексы уникальности; создать соответствующие DAO.
- Дополнить `ShineUsersCodec` инструкциями создания namespace/upgrade и новыми PDA seed; обновить program-account snapshot так, чтобы namespace не распознавался как пользователь.
- Сохранить поиск транзакций по economy-PDA (read-only account в инструкциях). В историю добавить распознавание создания namespace. При полном RPC snapshot восстанавливать и namespace, и on-chain пользователей.
- Не допускать, чтобы **полный Solana snapshot затёр/«понизил»** бесплатные Arweave-аккаунты, и чтобы повторный импорт платной регистрации создал второго пользователя. Переход `arweave → solana` обновляет ту же сущность в одной транзакции БД.
- Обеспечить воспроизводимость: переиндексация Solana + повторный Arweave импорт должны приводить к одному итоговому состоянию.
**Тесты:** чистая/обновляемая БД, повторный snapshot, повторный сертификат, два пользователя разных namespace, FK на профиль/контент/маршруты, upgrade без смены строки логина, восстановление checkpoint после рестарта.
**Готовность:** новая PostgreSQL-схема корректно хранит оба источника и namespace; периодическая Solana-синхронизация продолжает работать.
## Этап 6. Сервер-регистратор и DataItem
**Где:** `SHiNE-server/shine-server-config/src/main/java/utils/config/AppConfig.java` (чтение параметров); `SHiNE-server/shine-server-blockchain/src/main/java/blockchain/Ans104DataItem.java` (использовать готовый формат); `SHiNE-server/shine-server-archive/src/main/java/server/archive/TurboDataItemUploader.java`; новый отдельный Java-модуль/пакет `server.registration` или `server/archive/registration`; тесты `SHiNE-server/.../src/test/`.
**Действия:**
- Добавить настройки `freeRegistration.enabled`, `namespace`, публичный ключ регистратора, путь к приватному ключу/защищённый override, опционально тестовый email-код; валидировать, что публичный ключ совпадает с namespace-PDA.
- Сделать интерфейс `FreeRegistrationSigner` с методом подписать регистрационные поля и подписать ANS-104 payload; реализация `LocalKeySigner`, которую позже заменит signer на отдельном устройстве.
- Реализовать бинарный codec сертификата, строгий парсер, проверку ключа, двух подписей и namespace; внутренний Ed25519 подписывает только версию, полное имя и три публичных ключа. Внешняя ANS-104 подпись — весь DataItem с hash-email.
- Кодирующий модуль должен выдавать **точные сырые байты ANS-104 DataItem** плюс ID (а не просто JSON с полями). Публиковать через текущий Turbo uploader с отдельным тегом типа `free_registration`, не маскируя запись под обычный блок.
- Регистратор проверяет перед подписанием текущие локально синхронизированные логины, хеш email, поддерживаемый namespace и подходящий ключ; повторная выдача для уже зарегистрированного имени отклоняется. Это обычная корректность регистрации, а не разработка новой защиты от кражи ключа.
- Код `1111` — только временный сценарий тестирования; UI должен прямо сообщать, что письмо не отправляется.
**Тесты:** корректный DataItem проходит внешний/внутренний verify, изменение даже одного бита отбрасывается, секрет не попадает в логи/JSON, email не входит во внутреннюю подпись, отсутствие сертификата не заменяется «доверяем JSON».
**Готовность:** сервер способен подписать и загрузить без UI тестовую бесплатную регистрацию; Turbo возвращает DataItem ID.
## Этап 7. Arweave discovery, мгновенный импорт и восстановление
**Где:** `SHiNE-server/shine-server-archive/src/main/java/server/archive/ArweaveBlockSyncService.java`, очередь/DAO архива в `SHiNE-server/shine-server-db/`, новый импортёр сертификатов, docs Arweave/Blockchain по правилам репозитория.
**Действия:**
- В существующем `ArweaveBlockSyncService` обычные блоки проходят импорт отдельно: **новые сертификаты — отдельная ветка обработки**, не передавать их в `BchBlockEntry`.
- Реализовать единый `importVerifiedFreeRegistration(rawDataItem, provenance)` для обоих маршрутов: (1) мгновенно после успешного Turbo ответа (2) позже по Arweave discovery/повторному скачиванию.
- Сразу после Turbo ACK импортировать локально **тот же подписанный DataItem** через общий importer; запись в БД — следствие импорта, а не отдельный путь регистрации, создающий пользователя без артефакта Arweave.
- Добавить состояние загрузки `turbo_accepted / arweave_seen / confirmed / failed` (точные значения выбрать в реализации), обеспечив идемпотентность по DataItem ID и нормализованному логину.
- Учесть, что текущий `ArweaveBlockSyncService` пропускает GraphQL узлы без `block.height`: локальная активация не должна зависеть от этого фильтра. На других серверах регистрация видна по мере синхронизации.
- При конкурирующих сертификатах не считать порядок прихода на разные серверы глобальным порядком Arweave. До окончательного подтверждения хранить источник/статус, а при конфликтах использовать единое правило упорядочения подтверждённых записей; при штатной работе без конфликтов это незаметно пользователю.
- После перезапуска сервера очередь должна довосстанавливать сведения, а повторное скачивание не должно порождать дубликаты.
**Тесты:** instant login до высоты блока, повторный импорт не создаёт копий, GraphQL позже подтверждает, «не блок» не попадает в BchBlock импорт, рестарт, повреждённый DataItem игнорируется.
**Готовность:** бесплатная регистрация появляется локально почти сразу после принятия Turbo, а на других серверах после discovery.
## Этап 8. Единая серверная авторизация, маршрутизация и ограничения free-пользователя
**Где:** `SHiNE-server/shine-server-net-protocol/src/main/java/server/logic/ws_protocol/JSON/handlers/auth/{SolanaUserPdaImportService.java,Net_ResolveLoginForAuth_Handler.java,Net_SessionLogin_Handler.java,Net_CreateAuthSession__Handler.java}`; хендлеры смены ключей в `.../handlers/keyRotation/`; `SHiNE-server/shine-server-db/src/main/java/shine/db/dao/CurrentUsersDAO.java`, `SolanaUserPdaCurrentDAO.java`; маршрутизация `UserAccessServersCurrentDAO`; исходный `docs/API/`.
**Действия:**
- Сделать общий `ResolvedIdentity`/эквивалент: полное имя, root/client/blockchain ключи, `source`, наличие реального on-chain PDA, namespace и разрешённый сервер доступа. Платные читаются из Solana-синхронизации, бесплатные — из подтверждённого подписанного Arweave сертификата.
- На аутентификации free-user проверять пользователя и текущие ключи через единый индекс; не требовать существования Solana PDA для free.
- Для free получать сервер доступа **из namespace-PDA** (один общий сервер), а не из произвольных настроек клиента. После upgrade — из собственного пользовательского PDA.
- Ограничить серверные операции обновления root/client/blockchain ключей, access-server, форков с ключевой ротацией и связанные обходные пути; UI-блокировки — только дополнение.
- Сохранить публикацию обычных Arweave блоков, создание канала, связи, сообщения и текущую семантику session/login.
- Подготовить новые операции/ответы API: список namespace, проверка имени, старт free-registration, подтверждение кода/публикация, статус операции, статус регистрации пользователя; названия/структуры согласовать перед изменением публичного API согласно `AGENTS.md`.
**Тесты:** авторизация free/paid, wrong key, восстановление с password→keys, маршрутизация на namespace server, запрещённые key-rotation и access-server для free, действующие операции для paid без регрессии.
**Готовность:** после публикации free DataItem пользователь действительно входит, читает и публикует; доступ к смене ключей закрыт на сервере.
## Этап 9. UI: оба вида регистрации и переход free → Solana
**Где:** `shine-UI/js/pages/{register-view.js,registration-draft-keys-view.js,registration-payment-view.js,login-view.js,settings-view.js,access-keys-view.js,key-rotation-view.js}`; `shine-UI/js/state.js`, `js/router.js`, `js/services/solana-register-service.js`, `js/services/shine-user-pda-service.js`; при необходимости новые страницы `registration-method-view.js`, `registration-email-view.js`, `registration-upgrade-view.js`; стили в `shine-UI/styles/`; docs/API и регистрации.
**Действия:**
- На первом шаге предложить «Регистрация через Solana» и «Бесплатная регистрация»; показывать только namespace соответствующего типа, загруженные из синхронизированного on-chain реестра.
- Поля логин (часть до `@`), namespace (dropdown), итоговое полное имя, цена в SOL, минимальная/максимальная длина, занятость; убрать premium/promo UI.
- Платный сценарий: генерация ключей от **полного логина**, существующая страница оплаты, новая Solana-транзакция, сохранение ключей и авторизация.
- Бесплатный: локальная генерация тех же трёх ключей → email → тестовый код `1111` → запрос серверу на сертификат+Turbo → локальное принятие → автоматический вход; при сетевой ошибке не перегенерировать ключи и не терять черновик.
- В аккаунте free отображать статус, отсутствие Solana PDA, закреплённый сервер, блокировку ключей и CTA «Зарегистрировать в Solana». Показать реальные lamports/SOL из namespace.
- Upgrade использует существующие локальные приватные ключи; отправляет сертификат (внутреннюю подпись) и оплачивает тот же логин. После подтверждения меняет только статус и разрешения, не создаёт новые ключи и новый блокчейн.
- Удалить все остатки promo code UI, старой проверки premium и guard; обновить FAQ, ошибки, экран входа по полному имени.
**Тесты:** UI navigation, ввод регистрационных данных, корректное повторное открытие после ошибки, приватные ключи не отправляются на сервер, бесплатный вход почти сразу после Turbo, платный вход после Solana, upgrade без logout/раздвоения личности.
**Готовность:** все три пользовательских сценария доступны обычному человеку без ручных RPC/CLI вызовов.
## Этап 10. Сквозное тестирование, релиз на devnet и обратимость
**Где:** `shine-solana/shine/tests/`, `shine-UI/tests/`, Java unit/integration tests всех модулей, `scripts/devnet/`, `deploy/TEST_SERVERS.md`, `deploy/SOLANA_USERS_SYNC_SERVER_SETUP.md`, документация для операторов.
**План E2E:**
1. Поднять изолированную PostgreSQL с миграциями и новым синхронизатором; проверить чистый старт и повторный старт.
2. Deploy тестового `shine_users`, инициализация economy от любого подписанта, обновление economy от upgrade authority.
3. Создать платный и бесплатный namespace, проверить чтение из UI и через сервер.
4. Зарегистрировать `alice@shine` напрямую в Solana, проверить PDA v1.2, сумму оплаты, login/session, AddBlock, каналы и сообщения.
5. Зарегистрировать `bob@free` через тестовый код; Turbo ACK → мгновенный локальный вход → Arweave discovery → импорт на другой сервер.
6. Проверить занятость имени/hash-email, неверные подписи, попытки регистрации с другими ключами, попытки сменить ключи и access-server на free.
7. Создать Bob публикацию и канал **до** оплаты; зарегистрировать Bob в Solana с исходными ключами; убедиться, что Arweave история, доступ и идентичность остались прежними.
8. Проверить обновление/форки/смену сервера уже после оплаты, повторный on-chain create запрещён.
9. Проверить восстановление после падения Turbo/Arweave/RPC, возвращение отложенных данных, replay и full snapshot без потери бесплатных пользователей.
10. Протестировать с двумя dev-серверами, учесть отставание peer по Arweave, проверить, что не обещается мгновенная глобальная видимость.
11. Прогнать сборки `cargo test`/Solana-specific tests, Java Gradle modules, Node UI tests, ручной browser smoke-test.
12. Подготовить manifest и инструкции для clean devnet, в том числе program ID, upgrade authority, начальные namespace, соответствие серверного ключа и namespace.
**Откат:** отдельно для Solana (новые инструкции и PDA необратимы после записи в цепь), для DB (backup + миграционный откат только до появления новых данных), для server/UI (раздельное включение/отключение новой регистрации через feature flag). Отключение выдачи сертификатов не должно блокировать чтение уже созданных бесплатных аккаунтов. Production не обновлять без явного подтверждения.
**Готовность всего проекта:** все сценарии из пунктов 1–12 прошли в test/devnet, данные не пропадают, двойников нет, старые функции не деградировали, документация и версии совпадают с кодом.
---
## Карта зависимостей
`1 протоколы → 2 namespace в Solana → 3 платная регистрация в Solana → 4 JS Solana-кодеки`
`1 протоколы → 5 БД и синхронизация → 6 сервер-регистратор → 7 импорт Arweave → 8 единая авторизация`
`4 + 8 → 9 UI → 10 E2E/devnet`.
Параллельно допустимы только независимые тесты/документы. **Не начинать Этап 9 до рабочего серверного Этапа 8**; не деплоить новый контракт вместе со старым UI/синхронизацией на production.
## Открытые технические особенности (не требующие новых продуктовых решений)
- Сейчас `solana_user_pda_current` — корневая таблица многих FK; преобразование модели пользователей — самый рискованный серверный участок. Прежде чем писать миграцию, перечислить все зависимости и тестировать без разрушения старых данных.
- `ArweaveBlockSyncService` сейчас фильтрует записи по `block.height` и импортирует обычные блоки; сертификаты идут другой веткой и локальной немедленной обработкой.
- Текущая Solana-логика create привязывает `created_at_ms` к текущему времени; это обязательно учесть для старых бесплатных блокчейнов на этапе upgrade.
- На разных серверах нельзя считать «в какой последовательности я скачал DataItem» окончательным глобальным порядком. Даже если коллизии выдачи исключены организационно, безопасный импорт обязан проверять подписанта, и не должен заменять уже установленную идентичность произвольной повторной записью.
- Заявление «один email на всю SHiNE» при фиксированном коде `1111` означает уникальность **указанной строки email**, но не подтверждает владение почтовым ящиком. При задержке межсерверной синхронизации невозможно гарантировать идеальную моментальную глобальную блокировку без общего авторитетного регистратора; нынешняя схема предусматривает один регистратор.
- Экономический PDA в read-only accounts сохраняет **поиск через history/signatures**. Одно лишь чтение не обязано порождать account-change notification; периодический poll/snapshot уже существует, и остаётся.
- Проверка upgrade authority требует корректной работы с account `ProgramData`, а не сравнения с исполняемым Program ID и не обычного owner поля PDA.
## Что сознательно НЕ делаем
- `update_namespace`, `delete_namespace` и премиальные короткие имена.
- Реальный SMTP/email и восстановление доступа через почту.
- Подключение отдельного аппаратного регистратора; противодействие краже его ключа, выпуск сертификатов несколькими независимыми регистраторами.
- Миграцию старых Solana PDA и старого формата логинов в полном объёме; решается отдельным релизом.
- DAO governance-инструменты и редизайн прочих экранов.
## Чеклист передачи работы следующему сеансу (обновлять после каждого этапа)
```text
Текущий этап: ____ / 10
Текущая ветка/коммит: _________________________
Что уже сделано: ______________________________
Файлы изменены: ______________________________
Обновлённая документация: ____________________
Тесты (команда → результат): __________________
Что не готово/не проверено: ____________________
Нужен ли API/blockchain format approval: ______
Следующая конкретная задача: __________________
Что НЕ трогать: реальные ключи, prod без разрешения,
существующие Arweave блоки и чужие сценарии UI.
```
**Правило перехода:** следующий этап начинается только после отчёта о предыдущем и зелёных обязательных тестов. Не объявлять весь проект законченным по результату одного этапа.
@@ -0,0 +1,12 @@
# Регистрация server@shine — дополнение к патчу 0–13
1. Проверьте, что новая `shine_users` развёрнута в **devnet/localnet** и её Program ID согласован с UI и скриптами. Нельзя использовать старую Solana-программу с новым интерфейсом.
2. Проверьте, что `users_economy_config` PDA существует. Повторно инициализировать существующую economy-PDA нельзя.
3. От имени действующей upgrade authority создайте namespace `shine` типа 1. Можно использовать `shine-solana/shine/scripts/registration-v2/create-namespace.mjs` в devnet/localnet после проверки actual Program ID и флагов. Укажите `--namespace shine --type 1 --min-length ... --fee-lamports ... --rpc ... --keypair ... --send`.
4. Откройте `shine-UI/server-ui/create-server-pda.html` из опубликованной тестовой сборки SHiNE (не через `file://`). Укажите тот же Solana RPC, полный логин `server@shine`, серверный адрес (например, `shineup.me`) и пароль либо исходные ключи. Для нового серверного аккаунта `accessServers` можно оставить пустым, если политика проекта позволяет.
5. При генерации ключей используется **полный логин** `server@shine`: смена логина меняет результат KDF. Сохраните master secret/ключи безопасно; не отправляйте их на сервер или в чат.
6. Пополните показанный client/device-адрес для оплаты **rent + регистрационная комиссия из namespace + network fee**; проверка namespace выполняется перед отправкой. Для devnet используйте faucet. Не подставляйте mainnet-ключи в тестовые формы.
7. Зарегистрируйте сервер и проверьте транзакцию, PDA 1.2 с непустым `server_addresses` и запись о сервере в локальной Solana-синхронизации.
8. После этого создайте `free` namespace типа 2, указав полное имя `server@shine` и публичный ключ регистратора; скрипт проверит наличие PDA сервера. Настройте регистратор и серверную БД.
Ограничения: полная Rust/Java/PostgreSQL/Turbo E2E проверка проекта 0–13 не проведена. Не запускать на production. Админка читает price из namespace, но окончательную сумму rent определяет Solana-транзакция.
+81
View File
@@ -0,0 +1,81 @@
# SHiNE Registration V2 — аудит исходников, этап 0
**Дата аудита:** 2026-10-23. **Статус:** инвентаризация выполнена; интеграционные сборки Rust/Gradle/PostgreSQL не подтверждены (ограничения окружения).
## Исходник и правила
- Фактический исходник: `SHiNE-bundle-2026.10.23-12.36.02.zip`, SHA-256: `e2871bb11610437c354507dc9a723d64f14b0be4161af5f82d19f1466af648a6`.
- Мастер-план V2 от 23.10.2026 ссылается на архив от **22.10.2026**. Здесь взята более свежая **прикреплённая версия 23.10.2026**. Все ссылки на файлы проверены относительно этого архива; при переходе к другому commit провести повторный diff/аудит.
- Архив **не содержит `.git/`**: исходная ветка, коммит и чистота git-дерева неизвестны. В данном пакете не создан git-коммит, не выполнен push, не объявлена связь с remote-веткой. Для работы в настоящем репозитории нужна отдельная ветка, например `feature/registration-v2`, от **реального** текущего commit.
- Прочитаны обязательные правила: корневой `AGENTS.md`, `COMMIT_AND_VERSION_RULES.md`, `deploy/AGENTS.md`, `deploy/TEST_SERVERS.md`, `shine-solana/shine/AGENTS.md`, `SHiNE-server/AGENTS.md`, `shine-UI/AGENTS.md`. Дополнительные `AGENTS.md` в unrelated ESP32/DM/test-publisher/backup не относятся к редактируемым в этапе 0 областям.
- Код регистрации и действующий API/форматы/миграции **не изменены**. Production, testnet, секреты и реальные базы **не тронуты**. `VERSION.properties` не изменялся, поскольку не было изменений клиентского/серверного кода или git-коммита.
## Локальные инструменты и честный baseline
| Компонент | Фактически обнаружено | Результат |
|---|---|---|
| ОС/runtime | Linux, Java 21.0.12.1 | Java runtime есть; Gradle `java.toolchain` просит Java 17 |
| Node.js | v22.16.0, npm 10.9.2 | `node --test shine-UI/tests/*.test.*` — **18 passed / 0 failed** |
| UI parse check | `node --check` на `register-view.js`, `solana-register-service.js`, `shine-user-pda-service.js` | **3/3 успешны** |
| Java isolated | `javac --release 17 -d /tmp/shine_stage0_javac SHiNE-server/shine-server-db/src/main/java/shine/db/sql/CurrentUsersSql.java` | **успешно**, лишь изолированный Java-файл, НЕ сборка сервера |
| Gradle wrapper | `./gradlew --version` | **BLOCKED**: попытка загрузить Gradle 8.14 с `services.gradle.org`, `UnknownHostException`; Gradle не собран |
| Solana/Rust | `rustc`, `cargo`, `anchor`, `solana` отсутствуют | **NOT RUN**: Solana build/test невозможен в данном окружении |
| PostgreSQL | `psql`/Docker не обнаружены | **NOT RUN**: SQL migration/integration тесты не выполнены |
| Git | `/usr/bin/git` имеется, внутри архива нет `.git` | реальные branch/commit неизвестны |
**Команды для полноценной перепроверки в подготовленной среде:**
```bash
# Из корня отдельной рабочей ветки репозитория
./gradlew assemble
# Обратите внимание: в корневом build.gradle задача test отключена:
# tasks.named('test') { enabled = false }
# Поэтому ./gradlew test сам по себе не доказывает прохождение тестов сервера.
node --test shine-UI/tests/*.test.*
node --check shine-UI/js/pages/register-view.js
node --check shine-UI/js/services/solana-register-service.js
node --check shine-UI/js/services/shine-user-pda-service.js
cd shine-solana/shine
cargo test -p shine_users
# Специальные Anchor/local validator тесты — по AGENTS.md и тестовым конфигурациям;
# перед запуском убедиться, что тесты не используют реальные кошельки/production.
```
Для Java/SQL настоящих интеграционных тестов нужен безопасный локальный или выделенный **тестовый** PostgreSQL и подготовленная JDK17/Gradle инфраструктура. Не запускать деплой в production автоматически.
## Прямые точки изменений
| Подсистема | Файлы / исходное состояние | Этапы |
|---|---|---|
| Solana PDA | `shine-solana/shine/programs/shine_users/src/lib.rs`, `settings.rs`: `find_user_pda` строит 2 отдельных seed (`user_login=` и `login`), не SHA256 всей строки; program IX 1–6 | 1–3 |
| Экономика/guard | В `shine_users` есть `DAO_AUTHORITY`, `registration_fee_lamports`, `promo_seller` и CPI к `shine_login_guard`; сменить только новый registration flow согласно плану | 2–3 |
| Пользовательская запись | `shine-solana/shine/doc/formats/shine-user-pda-format-v.1.2.md` — не изменять формат существующей PDA без необходимости | 1–3 |
| UI PDA/transaction | `shine-UI/js/services/shine-user-pda-service.js`, `solana-register-service.js`, `solana-programs.js` — старые seed, promo и guard | 4, 11–12 |
| UI форма | `shine-UI/js/pages/register-view.js`: временная нормализация удаляет `_`, отсекает >20 символов, `MIN_REGISTRATION_LOGIN_LENGTH=8`; менять **одновременно с** полным логином и namespace | 11 |
| UI KDF | `shine-UI/js/services/auth-service.js`: `derivePasswordKeyBundle(login,password)`; после новой регистрации ключи выводить из полного `login@namespace` без изменения KDF | 4, 11–12 |
| Solana sync | `SHiNE-server/shine-server-solana-users-sync/src/main/java/sync/service/SolanaUsersSyncService.java`, `sync/codec/ShineUsersCodec.java`, `sync/util/SolanaPdaUtil.java`, `sync/source/rpc/SolanaRpcClient.java`, `sync/storage/postgres/PostgresStorageRepository.java` | 6 |
| База | `SHiNE-server/shine-server-db/src/main/resources/postgres/schema_v1.sql`; миграции через `migration_v32.sql`; `SHiNE-server/shine-server-db/src/main/java/shine/db/DatabaseInitializer.java` разрешает текущую версию 32 | 5–6 |
| SQL единый пользователь | `SHiNE-server/shine-server-db/src/main/java/shine/db/sql/CurrentUsersSql.java`: `usersSubquery` строит список **только** из `solana_user_pda_current` | 5, 10 |
| Server auth | `.../handlers/auth/Net_ResolveLoginForAuth_Handler.java`, `Net_CreateAuthSession__Handler.java`, `Net_SessionLogin_Handler.java`, `SolanaUserPdaImportService.java` (проверка сессий ходит в real Solana PDA) | 10 |
| Сервер доступа | `CurrentUsersDAO.java`, `SolanaUserPdaCurrentDAO.java`, `UserAccessServersCurrentDAO.java`, `AuthAccessScopeSupport.java` и SQL-функции refresh | 5, 10 |
| Key rotation | `.../handlers/keyRotation/Net_KeyRotationStart_Handler.java`, `KeyRotationSessionsDAO.java`, операции обновления PDA | 10 |
| Сертификат | `SHiNE-server/shine-server-blockchain/src/main/java/blockchain/Ans104DataItem.java`; `SHiNE-server/shine-server-archive/src/main/java/server/archive/TurboDataItemUploader.java` принимает подписанный DataItem, сам не подписывает | 7 |
| Arweave | `.../server/archive/ArweaveBlockSyncService.java`: обычный импорт зависит от `block.height`; требуется отдельный тип сертификата + локальный импорт по Turbo ACK | 8 |
| WS | `.../JSON/JsonHandlerRegistry.java`, `docs/API/01_User_Registration_API.md`, `docs/API/09_Operations_Index.md` | 9 |
## Ключевые найденные несовместимости с будущим V2
1. **Старый пользовательский PDA seed:** `lib.rs` использует `[b'user_login=', login.as_bytes()]`; новый план использует **один** сырой 32-байтовый SHA256 seed полного логина. Существующие legacy PDA автоматически не мигрируют.
2. **Старый UI:** `register-view.js` удаляет `_`, хотя `a_b` и `ab` должны быть разными пользователями. В Solana нормализация тоже ограничивает длину 20 (`lib.rs`); нельзя менять лишь одну сторону.
3. **Точка поиска Solana PDA в авторизации:** `SolanaUserPdaImportService.fetchRawUserPda` через `getProgramAccounts`/memcmp по offsets 61 и 62. Для нового типа аккаунтов потребуется корректное различение namespace и user PDA и прямые PDA-адреса, а для `FREE_CERT` — отдельный проверенный путь.
4. **Системная SQL-зависимость:** реестр логинов, связи, блоки, статистика, сессии, маршруты и уведомления имеют FK к `solana_user_pda_current`. Простая таблица «free_users» без переноса зависимостей неработоспособна: подробнее в `SQL_DEPENDENCIES.md`.
5. **Маршрутизация:** `shine_refresh_user_access_servers_for_user` (`migration_v16.sql`) читает `solana_user_pda_current` и его `access_servers_json` и ищет сервер только среди on-chain пользователей; для free должен быть server из namespace-PDA без фальшивого on-chain user PDA.
6. **DB миграции:** `DatabaseInitializer` обработал переходы 30→31→32 и требует итоговую 32. Для v33 нужно и отдельную миграцию, и обновление инициализатора, и сценарий как для чистой БД, так и для 32→33. Старые миграции не переписывать.
7. **Лимиты и история:** у бесплатного аккаунта до upgrade мог существовать контент и расход лимитов. Не сбрасывать при создании on-chain PDA; отдельно тестировать старую дату создания blockchain и новую дату Solana PDA.
8. **Необходимы согласования:** изменение публичных WS операций и формата **существующего** пользовательского блокчейна подпадает под `AGENTS.md`. Этап 0 не меняет ни того ни другого. Протокол нового отдельного сертификата разрабатывается на этапе 1 без маскировки под обычный блок.
## Очерёдность (основной мастер-план V2)
`0 аудит → 1 протоколы → 2 namespace Solana → 3 create/upgrade Solana → 4 JS-кодеки → 5 identity DB → 6 Solana sync → 7 signer → 8 Arweave importer → 9 WS API → 10 auth → 11 UI registration → 12 UI upgrade → 13 E2E / тестовый релиз`.
**Состояние на конец этапа 0:** точные файлы и SQL-зависимости найдены, UI smoke прошёл, Java isolate compile прошёл; полный baseline Java/SQL/Solana заблокирован отсутствием дистрибутивов/toolchain и БД. Следующий исполнитель должен повторить заблокированные проверки в dev-среде, прежде чем маркировать этап 0 полностью завершённым.
+76
View File
@@ -0,0 +1,76 @@
# SHiNE Registration V2 — связи с `solana_user_pda_current` (этап 0)
**Источник:** `SHiNE-server/shine-server-db/src/main/resources/postgres/schema_v1.sql`, текущие SQL-миграции до `migration_v32.sql`; Java исходники архива 23.10.2026. Это **статический** аудит исходников, а не `pg_catalog` реальной БД. Перед этапом 5 обязательно проверить живую тестовую БД через `pg_constraint`/`pg_trigger`/`pg_views`, поскольку baseline + миграции содержат переопределения.
## Foreign keys, объявленные в текущем `schema_v1.sql`
| Таблица-зависимость | Ключ таблицы пользователя | Исходная строка `schema_v1.sql` |
|---|---|---:|
| `user_access_servers_current` (два FK: пользователь и сервер) | `login` | 150–151 |
| `active_sessions` | `login` | 369 |
| `esp_pairing_settings` | `login` | 389 |
| `esp_pairing_requests` | `login` | 401 |
| `users_params` | `login` | 422 |
| `user_settings` | `login` | 435 |
| `channel_read_state` | `login` | 453 |
| `test_free_avatar_uploads` | `login` | 482 |
| `blockchain_state` | `login` | 502 |
| `blocks` | `normalized_login` | 518 |
| `connections_state` | `normalized_login` | 590 |
| `user_stats_state` | `login` | 684 |
| `user_push_tokens` | `login` | 745 |
| `user_notifications_state` | `normalized_login` | 856 |
| `key_rotation_sessions` | `login` | 2158 |
В текущем `schema_v1.sql` явно перечислено **16 FK** в **15 таблицах** на `solana_user_pda_current` (из них один двойной для `user_access_servers_current`). Проверить финальное состояние ограничений в PostgreSQL: в некоторых старых миграциях (`migration_v7`, `migration_v8`) FK накладывались через `ALTER TABLE`, а в `schema_v1.sql` уже представлены встроенными. Не применять миграции вслепую поверх готового baseline.
Дополнительные места объявления/изменения FK в `migration_v2`, `v7`, `v8`, `v9`, `v10`, `v14`, `v21`, `v26`: оригиналы нужны для трассировки истории схемы и корректной миграции существующих БД; не считать эти объявления отдельными дополнительными активными FK без `pg_catalog`.
## Функции и триггеры с зависимостью от таблицы
- `shine_refresh_user_access_servers_for_user`: финальная версия в `migration_v16.sql` (строка 4). Удаляет маршруты и пересчитывает их через `solana_user_pda_current u`, `access_servers_json` и lookup server `s` из той же таблицы.
- `shine_refresh_user_access_servers_for_server`: версия `migration_v16.sql` (строка 64); перечисляет затронутых пользователей в таблице Solana.
- `shine_refresh_user_access_servers_all`: исходная функция `schema_v1.sql` (строка 262) / `migration_v2.sql` (строка 116): массовое обновление маршрутов на основании Solana списка.
- `trg_refresh_user_access_servers_row` и `trg_refresh_user_access_servers_truncate`: подключены к `solana_user_pda_current` в `schema_v1.sql` (строки 313, 319) и `migration_v2.sql` (строки 167, 173), в частности реагируют на обновление/очистку on-chain snapshot.
- `shine_resolve_login`: `schema_v1.sql`, строка 965, выполняет lookup в `solana_user_pda_current` (строка 979).
- `shine_refresh_user_stats`: оригинал `schema_v1.sql`, а переопределение в `migration_v19.sql` (строка 6) проверяет наличие логина в `solana_user_pda_current` (строка 16). Функция повторно менялась в `migration_v31.sql`; перед этапом 5 получить конечное определение из реально инициализированной БД.
- `shine_channel_names_state_stats_ai`: определение `migration_v15.sql` (строка 3) читает `solana_user_pda_current` для логики канала; оценить влияние на free.
- `migration_v5.sql` содержит JOIN на `solana_user_pda_current` для connections. Проверить актуальность этого legacy-прохода на текущем schema baseline.
- `schema_v1.sql` объявляет `CREATE VIEW blockchain_state` и `CREATE VIEW blocks` около строк 2277–2279. Это **исторические/переопределяемые объявления**, не доказательство текущих зависимостей view от Solana. Проверить финальный `pg_views`/`pg_rewrite` до миграции.
## Вызовы из Java — единая идентичность / Solana-only допущения
- `shine-server-db/src/main/java/shine/db/sql/CurrentUsersSql.java::usersSubquery()` — источник логинов **только** `solana_user_pda_current`.
- Его потребители: `CurrentUsersDAO`, `ConnectionsStateDAO`, `Net_AddCloseFriend_Handler`, `Net_GetUserConnectionsGraph_Handler`, `Net_GetFriendsLists_Handler`, `ChannelsReadSupport`.
- Прямая зависимость от `SolanaUserPdaCurrentDAO`: `Net_GetMyBlockchain_Handler`, обработчики сессий и ротации через `SolanaUserPdaImportService`, `KeyRotationSessionsDAO`.
- `SolanaUserPdaImportService.fetchRawUserPda` делает `getProgramAccounts`/memcmp и предполагает user PDA; это **не** способ признавать free identity.
- `AuthAccessScopeSupport` опирается на `UserAccessServersCurrentDAO` и на маршруты, созданные из Solana PDA.
- `SolanaUsersSyncService` + `PostgresStorageRepository` создают/перезаписывают snapshots; не допустить, чтобы sync очищал доверенные free-сертификаты или создавал дубль при Solana upgrade.
- `ArweaveBlockSyncService` читает `solana_user_pda_current` и blockchain-данные: восстановление free должно оставаться независимым от факта существования реального Solana PDA.
## Решение для этапа 5 — пока НЕ принято
Требование мастер-плана: одна логическая личность для `FREE_CERT` и `PAID_UPGRADED`; при free **нет on-chain PDA**, но сохраняются FK/индексы/функциональность сообщений, каналов, связей и сессий. Не вставлять фиктивный Solana snapshot со slot/signature только ради удовлетворения FK. Выбрать единый identity-index после проверки реальной схемы и протестировать:
1. создание free до появления в Solana, работа всех 15 зависимых таблиц;
2. транзакционный upgrade без перегенерации root/blockchain/client и без переименования логина;
3. re-sync snapshot Solana и повторный импорт сертификата, отсутствие потерянных FK/двойников;
4. безошибочный sync/route, если namespace server зарегистрирован в Solana, а сам free-user — нет;
5. rollback сценарий **только** для изолированной тестовой БД до появления новых данных.
Проверки каталога PostgreSQL на этапе 5 (проверить в тестовой копии, не в production):
```sql
SELECT conrelid::regclass AS dependent_table,
conname, confrelid::regclass AS referenced_table,
pg_get_constraintdef(oid) AS definition
FROM pg_constraint
WHERE contype='f' AND confrelid='solana_user_pda_current'::regclass
ORDER BY 1,2;
SELECT tgrelid::regclass AS table_name, tgname,
pg_get_triggerdef(oid) AS definition
FROM pg_trigger
WHERE NOT tgisinternal AND tgrelid='solana_user_pda_current'::regclass
ORDER BY 1,2;
```
@@ -0,0 +1,22 @@
# SHiNE Registration V2 — приёмка на devnet/localnet (этап 13)
## Проверено локально в этом патче
- `node --test shine-UI/tests/*.test.mjs` — контракт JS/namespace (результаты записывать по фактическому запуску).
- Проверка синтаксиса новых JS страниц и API — `node --check file.js`.
- ZIP `testzip` и patch application vs исходный архив.
## Обязательно выполнить на стенде (ещё не выполнено)
1. `./gradlew :shine-server-net-protocol:compileJava :shine-server-archive:test :shine-server-solana-users-sync:test` с работающим интернетом/cache Gradle.
2. Solana `cargo test`, `anchor test`, local validator: IX7 type1/type2, чужая ProgramData/authority, 32B PDA seed, Ed25519 root/blockchain/registrar и точные суммы.
3. PostgreSQL: чистая БД с v33/v34 и обновление existing до v34; проверить FK, snapshot и сохраняемые связи/каналы.
4. Настроить вне Git registrar 32B seed, Turbo credits, отдельный test namespace type2; API на dev WS.
5. В браузере: `alice@shine` paid → профиль, блоки, каналы; `bob@free` → логин → email → `1111` → Turbo → мгновенная сессия.
6. Два сервера: второй находит ту же запись из Arweave, правильный owner, inner signature, отсутствие дубликатов.
7. У Bob создать сообщения и канал, затем Solana upgrade; сравнить login, три ключа, хеш цепи, число блоков, каналы, used bytes, DM, доступ до/после. Если хоть один отличается — release blocked.
8. Отрицательные тесты: неверные подписи, повтор email/login, потеря WS ответа, Turbo timeout и restart, попытки free key rotation/access-server.
9. `GetRegistrationStatus` не должен возвращать секреты/сырой email; `CheckRegistrationEmail` ограничить на reverse proxy/IP при публичном развертывании.
10. После полного E2E сформировать отчёт с commit/версиями, backup, отдельный Solana deploy и rollout server/UI. Production НЕ менять без разрешения.
**Release status: NOT READY.** Код — тестовый кандидат, отсутствие ошибок при `node --test` не подтверждает работоспособность всей сети.

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